How to Automatically Share Teachable Students to Google Drive Files and Folders when they Enroll in your Course

Not only are Google Workspaces, Google Sheets, Docs, Forms and Slide great to work in and look awesome, but the convenience of collaborating and sharing your Google Drive Files and Folders is also super useful. So much so that many course creators share their documents with their students all the time.

The problem that course creators have is that they are generally stuck with two options when sharing their Google Drive files and folders:

  1. Set sharing to Anyone with Link can view. And hope other freeloading students don’t find and share their course material.
  2. Manually share each student as they enrol. Which is time-consuming for the course creator and annoying for the student who needs to wait to be shared before they can get their hands on your awesome course content.

Both options are really terrible.

I reluctantly chose option one for my first Google Sheets Essentials Teachable Course and it really bothered me. I needed to find a way to share my Google Drive course content with only those students who signed up for my course.

In this tutorial, I will guide you through creating a Google Apps Script web app that receives a webhook notification when a student enrols onto one of my Teachable courses. If a student enrolled with a non-Gmail or non-Google Workspace domain email account, they will be sent an email with an attached form to add a Google-friendly email.

If you want a copy of the Google Sheet with the Apps Script attached, without coding it all yourself, plus written-visual tutorials on how to quickly set up your sheet head over to my teachable page now and purchase the sheet and instructions for just $2.95. Yeap not even the price of a cuppa.

The fun thing is that you will experience how the whole process works, because…well…that’s how I am going to share the Google Sheets file with you when you enrol. Neat, hey?

As a part of your purchase you will also get a few other perks:

  • Set files or folders for ‘view’, ‘comment’ or ‘edit’ access. 
  • Add existing students to your selected course Google Drive Files and Folders.
  • Get your full course list from your Teachable site right in your Sheet. 
  • A choice to bulk set your files and folders to:
    • prevent downloads, copying and print.
    • Prevent sharing by any documents you have provided ‘edit’ permission to.

If you want to understand how it all works and build your own, read on, you can always throw a couple of coins at me and enrol to run the workflow just for fun.

Instantly share ONLY Teach:able Students to selected Google Drive Files and Folders

 

If you are looking to build your own Teachable Course you can check out a how-to guide here:

How to launch an online course—and craft your email strategy

How it all works

We will be making use of Teachable’s handy webhooks to receive instances when a student enrols on one of our chosen courses.

We will need to set up a Google Sheet that contains two Sheet Tabs. One for our list of shared files and folders by course and one with our list of registered students.

We will also need to create a way to send a message to any student who has not registered to our Teachable school with a Gmail or Google Workspace domain email and ask them to provide a Google-friendly email. Once they reply we need to automatically share them with their new email.

Let’s Get started.

Creating your Google Sheet Manager

First, we need to create a Google sheet manager to make it easy for us to:

  • Add files and folders that we want to share with our selected courses.
  • Keep a record of our shared students by course.
  • Receive and manage form responses from students who need to provide a Google-friendly email.

Go ahead and create a new Google Sheet.

Setting up your Google Sheet

Name your Google Sheet workbook whatever you want. I’ve named mine:

Share Teachable Students to Google Drive Elements

Store File and  Folder Locations

Rename ‘Sheet1’ to ‘Shared Locations’.

In row 1 enter the following Headers:

  • Course Name
  • Course ID
  • File/Folder Name File
  • Folder URL

Google Sheets teachable connector tutorial Share Locations setup

Get the course ID for your Teachable Course

First, head over to your Teachable school. Log in and then select a course.

Navigate to your School Course page and select a course.

Google Sheets teachable connector Shared Locations select course

When the course loads, take a look at the URL, you will see the numerical code.

Google Sheets teachable connector Shared Locations manual selection url

Select and copy it.

Head back to your Google Sheet Manager and select the ‘Shared Locations’ Google Sheets tab.

Now paste it into Column B and then update the title in Column A.

Next, add a name for your File or Folder in Column C. You add what you want here or leave blank if you are feeling lazy. Sometimes it is better to rename the file or folder so that it makes better sense in the context of this list. If you do this, your original file or folder will not change.

Finally, copy and paste in your URL for your file and folder in Column D. Here, you can either navigate to your Google Drive file or folder and copy and paste in the URL. Alternatively, right-click on the file > select Get link > Copy > Done. Then paste in your URL.

Rinse and repeat.

Your ‘Shared Locations’ Google Sheets tab should look like this:

Google Sheets teachable connector tutorial Share Locations complete sheetThe most important stuff here is Column B and Column D. We will use this in our Google Apps Script.

Create a named range

Next, selected the range A2:B50 > right-click > View more cell actions > Define named range. Then name the range ‘ShareData’.

Google Sheets teachable connector tutorial Share Locations named range
Click to Expand!

We will also use this in our code later.

Store Enrolled students details and Tokens

Create a new Google Sheets tab and call it, ‘Students’.

Next, in cell D1 add the header: For non-Google Accounts.

On row two add from Column A2:

  • Timestamp
  • Email
  • Course
  • Non-Google Email
  • Access Token
  • Token Submit Date
Google Sheets teachable connector tutorial Share Locations Students Sheet tab
Click to expand!

You can see in the image above how a student’s details is added. This is all done via our Google Apps Script.

In the example above we have a student who did not register with a Google-friendly email so we send an email with our form and our Access Token for them to reply with a Google-friendly email. This is all updated automatically.

 

Now it’s time to crack on with the fun stuff, the code. Go to Extensions > Apps Script. You will load your Google Sheet connected Apps Script Editor.

Rename the project. Generally, I rename it to the same name as the Google Sheet.

Creating the Google Apps Script WebApp

Our first task is to receive a notification from our Teachable page via a webhook that a new student has enrolled in our course. We can do this with a Google Apps Script custom doPost() trigger function and building a webapp.

The doPost(e) function allows us to receive information from an external app like our Teachable webhook.

Here is the basic code that will allow us to make sure everything is running successfully:

When we receive our webhook information it will be packaged inside our 'e' or event parameter as a JSON object in the e.postData.contents property. Line 3

Finally, we need to build our frontend environment with the HtmlService class’s createHtmlOutput() method. We will leave its parameter blank here. Line 5

The first deployment of the webapp

We need to deploy our webapp now to get its URL.

In the top right select the Deploy button.

authorise scopes for Google Sheets teachable connector webapp deploy button

A dropdown will appear. Select New deployment.

authorise scopes for Google Sheets teachable connector webapp new deployment

A pop-up window will appear. You shouldn’t have to make any changes here. The Description is optional, I usually put in ‘First Release’ for the first deployment.

‘Execute As’ should be set to “Me(youremail@gmail.com)”.

‘Who has access’ needs to be “Anyone”, because your Teachable account needs to access your webapp.

Select Deploy.

authorise scopes for Google Sheets teachable connector webapp new deployment screenAnother pop-up screen will appear with your webapp URL. Copy the URL and select Done.

authorise scopes for Google Sheets teachable connector webapp new deployment screen url copy

Setting up the Teachable webhook

Head over to your Teachable account and log into your school.

in the sidebar of your Dashboard, select Settings.

Google Sheets teachable connector webhook settings

Then select Webhooks.

Google Sheets teachable connector webhook webhooks

Select New Webhook

Google Sheets teachable connector webhook new webhook

Paste in the Google Apps Script webapp that you created.

Then select the New Enrollment.

Finally, click Create Webhook.

Google Sheets teachable connector webhook selections

That’s it. You’re all done.

Your webhook will remain in a pending state until a user enrols into your course.

Google Sheets teachable connector webhook pending

Testing the webhook

Either create a new student or use an existing ‘test’ student account. Make sure that they are unenrolled from one of your courses.

Go to your Teachable school and select Users > Students.

  1. Search for your test student.
  2. Check the box.
  3. Select Bulk Actions.
  4. Select Enroll in Course.

Google Sheets teachable connector testing webhook add user dialogue already have

Wait a little bit, and then head back to your Google Apps Script editor and navigate to the Executions tab.

You should see that the doPost() function ran and the status was completed.

Google Sheets teachable connector tutorial doPost test

Note! If your dummy student account is already enrolled in your course you will not receive a webhook. Teachable will not send a webhook action for something that has already occurred. Simply unenroll your dummy student and enrol them again.

What does enrollment JSON look like?

When your test doPost() function ran it would have collected the following information:

Let’s go ahead and build the propper doGet() function.

Completing the doGet() function

Once we have collected our dataContents we want to first make sure that the type property exists. If it doesn’t, it is unlikely that it is not a webhook and not one sent from Teachable. I’ve used a JavaScript Ternary operator to determine if this property exists or not. We’ll store this in our webhookType variable. Line 13

Next, we check if the type name is "Enrollment.created". If it is, then we will run our main function addUserToDriveElement() taking the dataContents object as an argument. Lines 16-18

Adding users to the Drive files and folders

We will now set up our main run function to complete our task we will call it addUserToDriveElement(). It takes our dataContents as a parameter here.

Here’s the code:

Set the variables

Our first task is to extract the student’s email, their name, course ID and course name from the dataContent.object object. You can find the path to these properties in the JSON example I shared earlier. Lines 10-13

Get the Shared Locations data

Next, we grab the current spreadsheet with the SpreadsheetApp Google Apps Script class and the getActiveSpreadsheet() method.

Remember earlier when we created our Shared Locations sheet tab that we also created a named range called ‘ShareData’. We can conveniently use the getRangeByName() method to get this range. This method takes the named range as an argument and returns the range constructor. From there we can call the getValues() method to grab all the values in each cell. Lines 16-17

Using reduce to extract course URLs

From the values that are retrieved from our ‘ShareData’ named range, we need to extract all the Google Drive files and folder URLs related to the current course that the new student has enrolled in.

Here we use the JavaScript ‘reduce’ method. This method allows us to iterate through our 2d array of ShareData and store only the URLs for our course.

For us, this function will take an accumulator parameter to store our results. We will also use the current value argument here to look at each row of data on each iteration. We will also need to set our initial value to an array so we can add our URL as an array. Lines 19-24

Giving permission

Next, we will attempt to give permissions to our selected files and folders to our newly enrolled students.

Not every student will have enrolled with a Google-friendly email so we need to send those students an email with an attached form. They fill out the form with a Google-friendly email and send it back to us to automatically share them with the course docs.

Now we don’t want just anyone to be able to fill out the form or a ‘charitable student to fill the form out multiple times for their mates. So we need to set a unique token for them.

First, we set the token variable to null, for students who have a Google-friendly email. Line 27

Next, we will attempt to share the student with our course files and folders using our givePermission() function which takes the list of courseUrls and the student’s email. If the function cannot share the student it will return true. We will store this the nonGoogleEmail variable. Line 28

Now we check if nonGoogleEmail was set to true. If it was, then we need to set a form trigger on our Google Sheet and connected Google Form ( We will create this soon).

Then we will email the student to ask them to provide a Google-friendly email with our emailStudent() function, which will return a unique token for the student. This function takes the students name, email and course name. These will be added to the student’s email. Lines 30 – 34

Finally, we need to add our new student to our Google Sheet  addStudentToSheet(email, courseID, token). This will add the student to the ‘Students’ sheet tab along with a date-time stamp.

Now that we have the main function stored out, let’s look at the connected functions.

givePermission(urls, email)

This function is called from addUserToDriveElement(dataContents) and has two parameters:

  1. URLs – an array of Google Drive files and folder URLs connected to the course.
  2. Email – a string containing the student’s email.

The function will return true if the email is a non-Gmail or non-Google Workspace domain email.

Setup for non-Google Users

First, we set a nonGoogleUser variable to false. This will only change if the email could not be shared on the files and folders.

Google Drive API permissions payload

Next, set up the permission payload. This will be sent to the files and folders to give permissions.

We are using the Google Drive advance API here rather than the Google Apps Script DriveApp. Why? Because it allows us to share users without sending them an email confirmation to inform them that they are shared. We want the sharing to be seamless and under the hood. So this is the better approach.

First, we need to connect to the Google Drive advanced service. On the right side of your Google Apps Script editor IDE select Services.

A popup dialogue will appear. Scroll through until you find the Drive API. Select it and then click Add.

Google Sheets teachable connector DriveAPI service connect

Now let’s add our permissions:

Yes, weirdly ‘value’ will equal the email. The role of ‘reader’ equates to ‘view’ access here too. Lines 12 – 16

Iterate through the URLs

We now need to iterate through each of our Google Drive files and folders URLs. We will use the JavaScript forEach method to run our execution inside an arrow function.

Converting the URLs to an ID

Unfortunately, the Drive API does not take a URL as an argument so we will have to extract the file and folder IDs from our URLs. We do this on lines 20 – 25.

First, we set an id variable to an empty string.

Next, we grab the URL of the file or folder stored in our Google Drive.

We will use the JavaScript split() method along with some regular expressions. This methods allows us to separate our string into parts based on a specified divider. For us, our divider with be a set of regular expressions.

In the first split, we want to separate the URL string by either /d/ or /folders/ these are the two primary types of URLs you will find in your Google Drive. For example:

  • https://docs.google.com/spreadsheets/d/1_wO551p6YASDFEeqziXckFBLHqFpW7rHkjF_uJ-UQBQ/edit#gid=0
  • https://drive.google.com/drive/folders/1CUIsbfcVEE-fjOwYqhXITBsdf3AD3js4

In our regular expression, our backslashes need to be escaped with a forward slash. So to get:

  • /d/, we use, \/d\/
  • /folders/, we use, \/folders\/

We can have our regular expression check for either condition use the pipe ‘or’ divider |. Which will give us this regular expression:

/\/d\/|\/folders\//

This will split our string into to an array like this:

We only want the array item at [1] here. So we extract that before moving on to our next split.

.split(/\/d\/|\/folders\//)[1]

Now we want to remove any trailing data after the backslash. We do this by searching for the next backslash and splitting it and then grabbing the array item at [0].

.split(/\//, 1)[0]

This will give us our id.

Attempting to give permission to the user

We need to send our request to share the user to the Google Drive API inside a JavaScript try-catch statement. If a non-google email is shared, it will result in an error and we don’t want our script to stop.

First, we call the Google Drive API Permissions class and then use the insert method to share our students with their permissions. The insert method is going to take 3 arguments:

  1. permission – the permission payload we created above our loop.
  2. id – the ID of the file or folder.
  3. optional query parameter – This we want to NOT sent a notification email.

Resolving non-google friendly emails

If the email is not a Gmail or Google Workspace Domain email then the Drive app request will throw an error. This will be handled by the catch statement.

The catch statement will return an 'e' error event object. This will contain the ‘message’ property. If the nature of the error is that the email could not be added because it was not a Google-friendly email, the student’s email will be reported in the error message. Then we can return our catch statement with nonGoogleUser set to trueLines 38-41

We also want to make sure that any other errors that occurs are actually caught and stored so we will throw a new error with our 'e' error message.

 

Finally, we return our nonGoogleUser true or false result back to the main addUserToDriveElement().

 

Add Student To Sheet

The final task of the main function is to add the student to the ‘Students’ sheet tab.

addStudentToSheet(email, courseID, token) takes 3 parameters:

  1. email: the email of the student. Either Google-friendly or otherwise.
  2. courseID: the ID of the course.
  3. tokennull if the student has a Google-friendly email, otherwise this will be a string containing the token that the student will be sent.

First, we need to select the ‘Student’ Google Sheet tab. Line 9

Next, we will grab your locations date time stamp using the JavaScript new Date constructorLine 11

If we have a token, then we want to append our row with:

  • date timestamp
  • nothing here
  • course ID
  • non-Google friendly email
  • student token

If the student doesn’t have a token then we append the row with :

  • date time stamp
  • email
  • course ID

That’s it for sharing users to selected files and folders. Next, we will look at what to do with students with non-Google emails.

Dealing with non-Google emails

Once we have discovered that the student has a non-Google friendly email we need to send the student an email with a Google Form attached.

Before we get stuck into our code, we need to build our Form.

Connect the form to your Google Sheet Manager

In your Google Sheet Manager go to Tools > Create a new form.

Google Sheets teachable connector tutorial form new

A new window will appear with a Google Form editor. Before we work on our form, head back to your Google Sheets Manager and you will notice a 'Form Response1' sheet tab has been added to your workbook. Rename it to exactly: Access Request.

Google Sheets teachable connector tutorial form Access Request We will use this Form Sheet tab name in our code so it needs to be exact.

Creating your Google Form

Create the form

Your form should look like this:

Google Sheets teachable connector tutorial form creationSet your form title to:

Students Access For Google Drive Course Data

Next, add a short answer field and name it exactly, “Email”. We will be referencing this name in our code in a minute.

Make sure this item is set as required. 

Also select the vertical ellipsis at the bottom right and select response validation.

Set the short answer response validation to Text > Email.

Google Sheets teachable connector tutorial form creation validation

Next, go back to the three vertical ellipses in the bottom right and select Description. Enter the following description:

Please provide a Gmail or Google Workspace email to access the drive documents for the course.

Now, add another short answer item and call it exactly, Access Token. We will be using this title for the item again in our code so make it exact.

Set the item to Required and the description to:

Your exclusive access token.

Get the form Prefill URL

We want to be able to pre-fill in the student’s access token for them in the Google Form. To do this, select the vertical ellipsis in the top right of your form editor and then select Get pre-filled link.

Google Sheets teachable connector tutorial form prefill 1
Next, add something like 11111 to your Access Token item and select, Get link. A little popup will appear, select the Copy link button here.
Google Sheets teachable connector tutorial form prefill 2

Open up a text editor or something and paste in the URL. You should have something similar to this:

https://docs.google.com/forms/d/e/1FAIpQLSeOY584mfR_WOGt-Nsov2ycTypzrSXeFrlqOzocKK9Vd_HQ4Q/viewform?usp=pp_url&entry.1257072962=11111

Of course, your form ID and entry id will differ from the example above.  We will use this URL in a moment.

emailStudent()

When we discover a non-Google URL the main addUserToDriveElement() function call the emailStudent() function. This function takes 3 parameters all as strings:

  • email
  • studentName
  • courseName

Our first task is to get the form with our getFormURL() function which takes the form Sheet tab name “Access Request” as our argument. (More on this function in a moment) Line 15

Create a random-ish token.

Next, we create the unique student token that we will add to our Google Form.

Here I am lazily combining two random alphanumeric strings together to create a random number. Line 16

Setting up the email data

First, we set up our email subject. Here we use JavaScript template literals to create our string and include the course name at the end of the subject. Line 18

Next, we create the HTML for our email message to our students. First, we will add in the student’s name and course programmatically. Line 20

The most important thing to note here is the URL link ot the form. We first reference the form URL from our form variable we generated above. Next, we need to go to where we stored our prefill URL and copy this portion of it:

https://docs.google.com/forms/d/e/1FAIpQLSeOY584mfR_WOGt-Nsov2ycTypzrSXeFrlqOzocKK9Vd_HQ4Q/viewform?usp=pp_url&entry.1257072962=11111

?usp=pp_url&entry.1257072962=

Note that your entry number will change. So make sure you use your own number here.

Also, if you do wish to make a copy of this for another project, then the entry number won’t change thankfully.

Emailing the Student

Finally, we need to email the student. We will use a try-catch statement again just in case there is a weird email, but it should be okay if Teachable accepted it.

To send our email we make use of the sendEmail() method of the Google Apps Script GmailApp class.

The sendEmail() method takes the following parameters:

  • email
  • subject
  • body
  • options

We don’t put anything in the body because we want to use the htmlBody property of the options parameter.

Also, in our optional parameters, we can set noReply to true so that the user doesn’t try to reply to the email and also we can set the senders name to ‘Auto Reply’ to make it all cool and official.

If there is an error with sending the email we throw a custom error in the catch block. So we  do this at the end.

 

Finally, we return the token back to addUserToDriveElement().

getFormURL(sheetName)

This function is called from the emailStudent() function. It takes the sheet name of the Google Form sheet tab in the Google Sheets Manager. This should be, ‘Access Request’.

The published form URL is returned.

The reason we use this approach ass opposed to hard coding in the Form URL is that we might want to make a copy of our Google Sheets Manager and attached form and that means the Google Form URL will change.

First, we grab our active Spreadsheet and then get the form sheet by name and its associated form URL. Lines 8-9

We use this form URL in the Google Apps Script FormApp class with the  openByUrl() method. Next, we grab the published URL with the getPublishedUrl() method.

This is all returned back to the emailStudent() function.

setFormTrigger()

Back in the main addUserToDriveElement() function we call the setFormTrigger() if a user does not have a Google-friendly account.

We only want to set this trigger once and only if we have a user in our school who has enrolled with a non-Google friendly email.

We will store a property called, 'hasTrigger' in our Google Apps Script Properties Service. Our first task is to check if there is a property by this name and if it has been set to true. If there is no such property, it will be set to null. Lines 8-9

If there is no such property, then we want to create a trigger. Line 12

To do this we use the Google Apps Script ScriptApp class’ trigger builder. First, we set the newTrigger to call the function 'tokenSubmit'. Then we will specify that it is for the current active spreadsheet and set the rule that the trigger should occur when a form response is submitted to the Google Sheet. Lines 14-17

Then we will set our Properties Service  'hasTrigger' property to true for next time.

tokenSubmit(e)

When a student resubmits their Google-friendly email we need to first verify that there is a matching token in our ‘Students’ sheet. If there is, we need to share them on their course files and folders and add them to our ‘Students’ list.

The tokenSubmit(e) function is triggered when a student submits their form with their Google-friendly email. The onFormSubmit trigger carries an Object with the student’s Google Form input information as a parameter.

I’ve left an example in the code for you to see how it will look.

First, we grab an object of names values that should look like this (Line 17):

Next, we need to grab the range from Col A through to F of our Students sheet tab and grab the values as a 2d arrayLines 20-25

We will set a row number to the first email row under our header. We will use this to find the actual row in the Sheet where our corresponding user will be. Line 27

Find the corresponding row to the token

Next, we will use the JavaScript Find method to determine where the token is in the array if it exists.

Javascript Find MethodThis function will iterate through our 2d array trying to find the row that contains our matching access token and ensure it already has not been filled in.

Find takes a row parameter and can take an optional indexing parameter.

If row 4 (Column E) matches our Access Token from our form and row 5 (Column F – Token Submit Data) is empty then we will update the rowNum and add the new email to Column B and the current Timestamp to Column F.

Sharing the student with the course

If a matchRow exists we want to share the student with the course and record their new email.

We used the same JavaScript reduce method we used in our main run function (Yeah yeah, refactor it, Yagi!).

Then we send the results to the givePermission() function.

Finally, we get the range of the current student in our ‘Students’ sheet tab and update the row. Line 54

Redeploying  your Webapp

You now need to go back and redeploy your script for it to work with your Teachable webhook.

Before you do give your script a run. Maybe try and run the doGet() function. It will come up with an error, but it will also go through authorising all of your scopes.

Next, click the Deploy button on the top right of your Google Apps Script editor. Select, Manager Deployments.

Google Sheets teachable connector final deployment

Select the pencil icon to edit the deployment.

Then change the version to New version. 

Finally, select Deploy.

You are all done!

Conclusion

That’s it you made it through. How did you go? Any errors you had to work through?

If you are looking for a full copy of the code and the connected Sheet and Slide, to simply copy and paste in and run, plus a heap of extra bonus content you can sign up to the corresponding teachable course for a measly $2.95. Yep, less than the price of a cuppa and you would really help me out to keep this site running and making great content for you.

Instantly share ONLY Teach:able Students to selected Google Drive Files and Folders

OR…

If you have found the tutorial helpful, why not shout me a coffee? I'd really appreciate it.

I hope you found this tutorial helpful and you have been able to implement it in your own Teachable site. I would love to hear what site you used it on in the comments. Plus it is a bit of promotion for your own course!

~Yagi

How to programmatically schedule weekly time triggers between two dates in Google Apps Script

Carelessly left behind Google Apps Script time triggers can be greedy little blighters that can ultimately end in a whole lot of noggin scratching when your scheduled scripts decide not to run all of a sudden. Then there is a whole lot of house cleaning to remove all those time triggers you couldn’t be bothered setting a calendar reminder to remove them when you didn’t nee them any longer.

After all, there are some pretty tight quotas for the Consumer account (90 min) and if you are doing some heaving lifting in your Google Workspace account (6 hrs), then it will add up fast. Well… maybe I am just a glutton for triggers.

In this tutorial, we will cover how to schedule weekly time triggers between a period of dates in Google Apps Script programmatically using the Clock Trigger method of the ScriptApp class. The code basically sets all the triggers up on the desired range of dates and then removes all the triggers when the time expires.

Let’s get stuck into it!

The Code

Triggers.gs

This is the main code you will copy and paste into your own project. Read the Quick Use guide for what you will need to update for your own project.

ExampleFuncitons.gs

This file is just an example of the functions I have assigned for my project in my runsies() function.

Quick use guide

Here, we will quickly go through using the script to get you up and running.

The Example

In the example, we have an imaginary document that needs to be edited by our team. If you look at the ExampleFuncitons.gs file you can see our list of time trigger task for our Google Apps Script project as follows:

  • Refresh the Google Sheet: We possibly need to send a report and clear it out at a certain time to set it up for the next week.
  • Open and send an access email: We will send off an email to our team to let them know that they now have edit access for the sheet and complete their weekly task.
  • Send a deadline reminder: Just before the deadline, we send out a reminder to our stragglers that the deadline is due so that they can get unnecessarily offended. 🙄🐐
  • Remove the editors from the sheet: Once the deadline hits, we revoke edit access for our team from the sheet to maintain the integrity of the sheet before we send off our report.

Before you add your trigger times

A note on time zones

Just hold up one second. Before you add your trigger times, I recommend that you double-check the time zone assigned to your project.

Didn’t know that was a thing?  No worries. Check out this short video on how to get that done fast:

And you can dive a little deeper here:

Help! My time triggers are not in sync! : How to update your Google Apps Script project time zone.

Adding the script into your project

I recommend creating a separate *.gs file to add in the timeTrigger object from lines 35-145. It just gets it out of the way of your awesome project codes.

The runsies() function is just an example function. If all you want to do is add your triggers days and dates in and hit run, then it is fine. But if you want to programmatically draw your start and end trigger dates and weekly trigger times from somewhere else then all you need to add into your own function is the  TIME_TRIGGER objects and then run:

timeTrigger.deploy(TIME_TRIGGER);

Adding your times and date window

There are two parts to this object. First, set the start and end date that you want to run your weekly triggers. Lines 4 & 5

If you want to start your triggers straight away, then you can enter “now”, otherwise enter in a date. You will get an error message if your date is before the current date.

The end date removes all the time triggers in your project. So if you have other triggers, you will need to make some changes to the timeTrigger object (Maybe register each trigger id in PropertiesSerivce).

To add your dates, start with the year, month and date. Note that unlike the weirdness of the Javascript Date() constructor, I have made the month the common number. So a 3 will be March (not April in the Date() constructor).

Next, add the weekly triggers that you want to run each week for this project. Lines 21-28

You can add in as many as you want here. In the example, I have added four. Each piece of weekly trigger data is contained in an array:

[function, weekday, hour]

  • function: The function that you want to be triggered.
  • weekday: Full word days of the week from Monday to Sunday.
  • hour: The hour of the day that you want to run the trigger.

Deploying and scheduling the time trigger

To schedule, your  triggers run the timeTrigger.deploy(TIME_TRIGGER); function.

If you want to test things before your first deploy, you can check the triggers are all set up you can check the triggers in your Apps Script menu (1).

List of triggers in Google Apps Script Editor IDE
Click to Expand!

To check the times of your trigger, you can click on the vertical ellipses beside each trigger (2).

You can delete all the triggers in your project and start again with:

timeTrigger.remove();

That’s pretty much all you need to know to get this script up and running in your project.

If you want to learn more about how the timeTrigger object was written and how to code Clock Triggers, jump down into the next header.


Looking to learn more about Google Apps Scripts in a more structured format? Udemy has some great courses that can get you from the basics to a real Google Apps Script pro.

Got a more specific problem you need help with, but don’t have the time to develop the skills? I can connect you with a trusted freelancer. I have a team of hand-picked experts ready to help.

*The above affiliate links have been carefully researched to get you to what you specifically need. If you decide to click on one of these links it will cost you just the same as going to the site. If you decide to sign up, I just get a little pocket money to help pay for the costs of running this website.

Code breakdown for timeTrigger

timeTrigger.deploy()

The timeTrigger.deploy() function is the main run function and takes the object of start and end dates and weekly triggers that we assigned in the TIME_TRIGGER object in the runsies() function.

Its first task is to set the date the weekly triggers need to be removed. This is done with the setEndDateTrigger(triggerData) function that we will discuss in a minute.

Check if start dat is now

Next, we need to check the input for the triggerData.startDate. If the user selected “Now”, then we immediately run timeTrigger.setTrigger() and complete the script. Lines 12-16

Check if start date is today

Alternatively, if the user puts in the current day’s date then we need to run the timeTrigger.setTrigger() straight away too. First, we need to transform the users triggerData.StartDate data into a readable date. We do this using the Javascript new Date() constructor that has the option to take the format; year, month, date:

new Date(year, month index, day of month)

Because the month index for Date()  starts at 0 for January and ends at 11 for December, so we need to subtract 1 from the users month input before creating the date. Line 18

I used a Javascript spread operator (…array) to add in all the values of triggerData.StartDate which in our example are:

[2021, 3, 8]

So:

new Date(...triggerData.startDate)

Is actually, this:

new Date(2021, 3, 8)

Which is much tidier than:

new date(triggerData.startDate[0], triggerData.startDate[1], triggerData.startDate[2])

I’m really digging the spread operator lately. 

Next, we need to compare the current date with the triggerData.startDate. We can do this by converting the two dates to times using the getTime() method. This transforms the dates into long number values that can be compared. Line 25

Before we do this though we kinda need to clear the current time out of the current data otherwise we won’t be able to compare things properly (line 26). When we run new Date() to create the today variable it will give us the date and the current time all the way down to milliseconds. However when we created the date for our scheduled date we only added the year, month and day so the time will be set to midnight.

Let’s update today date by changing the time of the day to midnight with:

today.setHours(0, 0, 0, 0);

If start date is in the future, schedule it!

Our final condition is if the user has scheduled a date in the future. We don’t want to clutter up their trigger quota unnecessarily so we need to postpone our triggers. To do this we ironically, need to create a clock trigger that runs only once on the date we want our weekly triggers to start.

To programmatically set a time trigger in Google Apps Script we call the newTrigger method in the ScriptApp classLine 34

The newTrigger method takes our assigned function as an argument. This is the function we want to run when our trigger goes off. For us, this is the timeTrigger.setTrigger() function that will build the weekly triggers.

Running setTrigger() also starts the process of building the trigger.

Your next step is to decide what type of trigger you want. In our project, we want a timeBased() trigger. Line 35

Selecting timeBased() takes us to the Clock Trigger builder, where we can choose from a bunch of settings. For us, all we want to set is a start date so we chose the at(date) method which takes a constructed Javascript date. Here we throw in the startDate variable we built on line 19.

Once we have all our trigger data inputted, we need to create() our trigger.

timeTrigger.setEndDateTrigger()

The timeTrigger.setEndDateTrigger() function takes the triggerData as an argument. From that, it extracts the endDate array of year month and day.

Just like in timeTrigger.deploy(), we need to take one away from the month to get the proper value for Javascript. Then we want to remove our weekly triggers basically on the midnight of the following day after the user’s recorded end date. Lines 11-12

Why? Well, the end date usually means that it is a date the final trigger will occur on. We don’t want to remove our trigger before that date though or we will mess up our user’s process.

Once we have created our date we go through the same process as scheduling a start date in the future like we did in timeTrigger.deploy().

timeTrigger.setTrigger()

This trigger is initialised from either the timeTrigger.deploy() straight away if the start date is the current date or is scheduled for deployment at a later date.

The timeTrigger.setTrigger() takes the 2d array of all the weekly triggers assigned by the user. In our example, that was this:

First, it loops through each set of trigger input data with a forEach loop.

Assigning variables using destructuring

I want to assign a variable for each item in the currently iterated array so that I can work with it in building the trigger. Here I used a destructuring assignment now available in Google Apps Script V8 runtime. Line 11

If you are unfamiliar with the destructuring assignment, you can basically set an array of variables – in our case – on the left and assign (=) them to a corresponding array of data on the right. So:

let [nextFunct, weekday, hour] = time

Would assign these values to the varialbes on the first iteration:

let [nextFunct, weekday, hour] = ["refreshSheet", "Monday", 7]

Without destructuring this variable assignment might look like this:

Pretty cool, I reckon.

PReparing the days of the week

Next, we need to assign a day of the week to our clock trigger. These assignments require an enumerator which is basically:

ScriptApp.WeekDay.A_DAY_OF_THE_WEEK _IN_ALL_CAPS

Fortunately for us, we assigned our variable weekday to time[1] which is the day of the week for this iteration.

Lines 13-21

Creating the weekly clock triggers

Finally, we create our first clock trigger. Just like our date triggers we first call ScriptApp.newTrigger(nextFunct) where nextFunct is the time[0] value the user assigned as their function that they want to run on their trigger.

Again, we set the trigger to timeBased() but this time around we use onWeekDay() method. This method takes one of those weekday enumerators we store in our wkDay variable. We will select the correct one by adding weekday variable inside weekday:

wkDay[weeday] Line 25

For weekday triggers we can also set the hour of the day. This will deliver the trigger close to the hour selected. Line 26

timeTrigger.remove()

The timeTrigger.remove() function runs on the end date. Alternatively, you can run this to remove all of your triggers if you are testing on making a mistake.

To remove your triggers, you will first need to get all of your projects triggers. We do this with ScriptApp.getProjectTriggers();Then, you will need to loop through each trigger and delete the trigger using the deleteTrigger() method that takes the trigger object.

 Conclusion

I have been deploying triggers like this for a while now after and…erhm…unfortunate incident with meeting my quota and being lazy and leaving old triggers active. This now saves me a lot of future grief.

One thing you might have to adjust for a bigger project is the timeTrigger.Remove() method. If you have other triggers running in the same project, you probably don’t want to delete them. You could use the properties service to store your trigger ids and then check them against the list of all triggers to determine if they need to be deleted.

Another thing worth considering is that you might want to schedule multiple dates to run your triggers. You would need to loop through each start and end date here and create a trigger for each one.

Anyway, if you found this useful please give it a like in the comments below and if you have a plan to deploy it in your own project or a version of it I would love to hear about it in the comments.

Happy coding!

~Yagi

Help! My time triggers are not in sync! : How to update your Google Apps Script project time zone.

If you have made it to this post you are probably a little frustrates about why your Google Apps Script time triggers are not running on or around the times that you have designated. Of course, you could simply just be a well-oiled machine and want to know how to update the time zone of your project for your client.

To cut to the chase, the likely cause of clock triggers not running in the time range that you have selected is that the time zone in your Google Apps Script project is out.

How to check your Project’s Timezone

So, how do you check the time zone of your project?

If you need to do it programmatically you can use the Session class and the getScirptTimezone() method. Something like this will log your project’s timezone:


Alternatively, you can check out your project manifest file.

To do this in your Google Apps Script IDE, go to your sidebar and select the Project settings cog and then check the Show “appsscript.json” manifest file in editor checkbox under the general settings.

Google Apps Script manifest file
Click to Expand!

Go back to the editor and your “appscript.json” file will be visible. Select it and you will be able to see the current time zone for your project.

Google Apps Script time zone in manifest file
Click to Expand!

Changing the timezone

So, at the time of writing this, I found the information on the correct syntax for the time zone in the manifest in the docs either too simplified or when clicking the associated link, too convoluted for my poor goat brain to handle.

In short, you can add certain countries followed by their city. Like this:

“Australia/Sydney”

Or in your code, like this:

Alternatively, you can use GMT time in this format:

“Etc/GMT-10” << For Sydney, Australia

The -10 can be changed to whatever GMT you need.

Resources

After a bit of testing and some searching, I came across these two resources to help you when entering in the correct time zone.

Alternatively, I have created a Google Sheet that contains:

  • A full timezone list with aliases
  • A full timezone list without aliases
  • A GMT only list

These might be useful for bookmarking or exporting certain Google Sheet tabs as CSVs.

Just go to File > Make a copy so you have your very own version of the document.

Finally, here is a list of all the GMT values:

Standard Offset GMT
-12:00:00 Etc/GMT+12
-11:00:00 Etc/GMT+11
-10:00:00 Etc/GMT+10
-09:00:00 Etc/GMT+9
-08:00:00 Etc/GMT+8
-07:00:00 Etc/GMT+7
-06:00:00 Etc/GMT+6
-05:00:00 Etc/GMT+5
-04:00:00 Etc/GMT+4
-03:00:00 Etc/GMT+3
-02:00:00 Etc/GMT+2
-01:00:00 Etc/GMT+1
+00:00:00 Etc/GMT-0
+01:00:00 Etc/GMT-1
+02:00:00 Etc/GMT-2
+03:00:00 Etc/GMT-3
+04:00:00 Etc/GMT-4
+05:00:00 Etc/GMT-5
+06:00:00 Etc/GMT-6
+07:00:00 Etc/GMT-7
+08:00:00 Etc/GMT-8
+09:00:00 Etc/GMT-9
+10:00:00 Etc/GMT-10
+11:00:00 Etc/GMT-11
+12:00:00 Etc/GMT-12
+13:00:00 Etc/GMT-13
+14:00:00 Etc/GMT-14

And a link to the GMT converter:

GMT Converter

I hope this saves you a little time.


Looking to learn more about Google Apps Scripts in a more structured format? Udemy has some great courses that can get you from the basics to a real Google Apps Script pro.

Got a more specific problem you need help with, but don’t have the time to develop the skills? I can connect you with a trusted freelancer. I have a team of hand-picked experts ready to help.

*The above affiliate links have been carefully researched to get you to what you specifically need. If you decide to click on one of these links it will cost you just the same as going to the site. If you decide to sign up, I just get a little pocket money to help pay for the costs of running this website.

~Yagi

Google Apps Script: Create a Select All Checkbox to Tick Checkboxes in Any Desired Range in Google Sheets

Google Apps Script: isChecked(), switch, filter, map

One Checkbox to Rule them All

Now that’s a fantasy novel I could be my gums into.

Have you ever created a Google Sheet projects where you could really use a select all checkbox (they call them ‘Tick-boxes’ in Google Sheets)? Sure you can copy a range of tickboxes and paste the same range etc. But can you really trust your users not to mess that up?

People are used to select-all checkboxes in their computerised lives. It’s always better to work with familiarity to provide a better user experience rather than try and teach the user on the fly how to do something your way.

With this in mind, I went about creating a select-all checkbox for Google Sheets. Here is a little demo of how it all works. All the black background Tick boxes are select All boxes. These boxes have been assigned a range of other checkboxes that will be either checked or unchecked depending on the main select-all boxes state.

Google Select All Demo with Google Apps Script
Select All Demo

As you can see, the select all checkbox only changes the tick boxes in the assigned range. It does not affect any other non-tick box data in the same range.

To get this up and running on your own project, all you need to do is copy and paste in the two code files in your Google Apps Script editor. The first code file is the function that runs the check-all code. The other file stores all the select-all checkboxes and the ranges that they will affect.

Let’s take a look at the code and then run through a quick use guide before finishing off with an example.

Those of you who want to dive into the nuts and bolts of the code, there will be more explanation of each element of the code at the end.

The Code

Continue reading “Google Apps Script: Create a Select All Checkbox to Tick Checkboxes in Any Desired Range in Google Sheets”

Google Apps Script – URL Fetch JSON data from an API and add it to a Google Sheet – Ripple API example

Google Apps Script – UrlFetchApp, SpreadsheetApp, Ripple API, Time Triggers

I have been very fortunate of late to have the patronage of the Ripple XRP cryptocurrency community via XRP Tip Bot and Coil. This is no small part due to the support of user Recreational Rex from Twitter.

Full disclosure here, I don’t really know all that much about cryptocurrencies. I knew about Bitcoin and Ethereum but really didn’t really invest any time and money into looking at these growing forms of value exchange.

But now I’m a little curious.

I thought it would be fun to see what the value of XRP was against a fairly standard metric like the USD and keep a record of this exchange rate daily over a month or so (Mrs Yagi just read the ‘fun‘ in the last sentence and rolled her eyes).

I also thought it would be pretty cool to see how many exchange providers (Gateways) that conduct USD-XRP exchanges are around and see if there is much difference their exchange rate day-to-day among them.

Fortunately for me, the XRP Ledger provides a freely available open-source ledger that can be accessed via the Ripple Data API. The API can return JSON objects from which we can extract the data we need.

Of course, to record and display the daily exchange-rates I went straight to Google Sheets. I gathered the relevant XPR data using Google Apps Script’s UrlFetchApp Class and pushed it to my Google Sheet with SpreadsheetApp Class.

Here is a live embed of the XRP Google Sheet that is updated via a daily time trigger via Google Apps Script.

Continue reading “Google Apps Script – URL Fetch JSON data from an API and add it to a Google Sheet – Ripple API example”