There are only two commands built into the MailApp: sendEmail() and getRemainingDailyQuota(). Unsurprisingly, the one we need to use to send emails is sendEmail().

There are a range of parameters you can put inside the brackets of sendEmail() and you can view them all of the Apps Script Developers Reference page for MailApp. The most useful one is:

MailApp.sendEmail(recipient, subject, body, options);

where:

• recipient is the email address that the email is sent to, as a string (you can include multiple email addresses by separating them by commas)
• subject is the subject line of the email, as a string
• body is the plain text email, as a string (this means that it doesn't have any formatting - though we can add line breaks, as we'll explore below)
• options is extra information like any BCC or CC email addresses, if it should be no reply, or if there are any attachments, as a JavaScript object (see the Apps Script Developers Reference page for MailApp for more information on these options and how to format them).

Typically, instead of writing all of these things inside the brackets of sendEmail(), you will store them inside variables and then put the variable names inside the brackets instead. Here's an example of doing this:

var emailAddress = 'test@email.com';
var subject = 'Helpful email';
var body = 'This is a helpful email.';
var options = {noReply:true; cc: 'another-test@email.com'};

MailApp.sendEmail(emailAddress, subject, body, options);

When using MailApp, you must create a text string containing your entire email message. It is easier to break this into sections using += to add more content to the body variable, so it is easier to read in the Apps Script editor. If you want line breaks in your email (as you probably do), then you have to use \n, which means "new line" and is like hitting Enter on the keyboard (the backslash \ is an "escape character" to tell Apps Script the next value isn't text, and the n means "new line"). For example:

var emailBody = "Dear user \n\n";
mailBody =+ "This is an automated email to say that a script did something good. \n\n";
mailBody =+ "All the best, the person who wrote this script";

To set permissions, you must use DriveApp because you are working with a file or folder, and like with making a copy, you need to get the file first, using its ID. So you would use DriveApp.getFileById() or DriveApp.getFolderById() first, and store that in a variable. Then, you take that variable and use the .addViewer(), .addCommenter(), or .addEditor() command with an email address inside the brackets to set permissions.

// get the file and folder
var theFile = DriveApp.getFileById(docID);
var theFolder = DriveApp.getFolderById(folderID);

// add sharing permissions to the file and folder
theFile.addViewer(emailAddress);
theFile.addCommenter(secondEmailAddress);
theFile.addCommenter(thirdEmailAddress);

theFolder.addViewer(fourthEmailAddress);
theFolder.addCommenter(fifthEmailAddress);
theFolder.addEditor(sixthEmailAddress);

There are also plural versions of these commands (e.g. .addEditors(): which needs an array of email addresses rather than a single email address inside the brackets.

If a user already has access to a file or folder, adding higher permissions will "promote" their access (e.g. they already have View access, but they are given Edit access using Apps Script, they will be "promoted" to having Edit access).

Just like in Google Drive itself, you can remove access to files and folders as well as grant it. It works exactly the same, except you use .removeViewer(), .removeCommenter(), or .removeEditor(); with the email address of the user to remove inside the brackets.

theFile.removeViewer(emailAddress);

theFolder.removeEditor(sixthEmailAddress);

To create a new date in Apps Script (and JavaScript) you can use the command new Date(), either with nothing inside the brackets (that creates a date object that has the current date and time) or with other pieces of information in the brackets to create a specific date, like a date string (text formatted as a date) or a specific list of year, month, day, hours, minutes, seconds etc.

var todayDate = new Date();

A date in Apps Script has a specific default format, which for 08/01/2024 would look something like Mon Jan 08 11:30:34 GMT+00:00 2024. If you ran the code above and then logged that value, it would be in this format. We'll look at how you can change the format for more user-friendly outputs soon.

You might find that the date and/or time you get back is incorrect, because your Apps Script project is set to the wrong timezone. To change this, click on the gear on the lefthand side of the page to go to Project Settings and then adjust the timezone as needed.

To create a date object out of a specific date that isn't the current one, you can supply information inside the brackets of the new Date() command. For example, you can give existing dates that you might have elsewhere, such as in a spreadsheet of data or collected from a form. These are in string format, so must be inside quotation marks. There are specific date input formats you can use in Apps Script/JavaScript that it will be able to 'read' and turn into a date object. That w3schools page linked has in-depth guidance on different input formats you can use.

var oneDate = new Date("2024-01-02");
var anotherDate = new Date("04/03/2023");
var dateAndTime = new Date("January 11, 2024 10:30:00");

Whichever format a date string has, when you turn it into a Date Object using new Date(), it will have the output format above (Mon Jan 08 11:30:34 GMT+00:00 2024) unless you set it otherwise.

As we've seen, when you create a date object the default format is not particularly user-friendly, like Mon Jan 08 11:30:34 GMT+00:00 2024. If you want to write that date back into a document or email or spreadsheet, for example, then you might want it to be in a more user-friendly format, something that people might expect to see and read as a date (e.g. 08/01/24).

To do this, we can use the Apps Script Utilities service, with the command Utilities.formatDate(). The full syntax might be:

Utilities.formatDate(new Date(suppliedDate), timeZone, format);

Where:

• new Date(suppliedDate) is the new date object you create, giving it a date string to turn into a date object (or the brackets could be empty, to create one for the current date and time, for example if logging when an email was sent);
• timeZone is the timezone of the script in question, which can be got using the Session service and stored in a variable, like var timeZone = Session.getScriptTimeZone();
• format is the desired date format as a text string (so inside quotation marks), using d, M, y for the date elements and h, m, s for the time, e.g. "dd/MM/yyyy".

By doing this, you can create whatever date format you need when you have a date object. It is particularly useful when logging the date/time that something happened, as you can create a date object of the current date and time, and then format it in a more readable way for any users of the system.

If you're working on an Apps Script project that works a lot with dates and times, you can also create a little function that can convert a date to a specified format. Here's an example of one you could use:

function formatDate(suppliedDate, format){

//find script timezone
var timeZone = Session.getScriptTimeZone();

//generate formatted date
var formattedDate = Utilities.formatDate(new Date(suppliedDate), timezone, format);

//return formatted date to function that called this one
return formattedDate

}

And you could call this function in other functions, for example (with date being a variable containing a date):

var formattedDate = formatDate(date, 'dd/MM/yyyy');

Once you have a date object, you can get and set parts of the date object, for example the hours, minutes, seconds, year. The commands to do this are pretty self-explanatory in terms of naming: getHours(), getMinutes(), getSeconds, getFullYear, etc, and setHours(), setMinutes(), and so on...

These commands allow you to modify dates and times in various ways. You might remove the time part of a date (by setting them to 0) to be able to compare two dates, as date objects contain times as well as dates so the times must match if you want to use comparison operators like ==.

Another crucial use for these commands is to combine dates and times created separately. For example, if you had a Google Form and were collecting information about an event, you might have an eventDate variable, a startTime variable, and an endTime variable, from different fields on the form. If you wanted to create a Google Calendar event from this data, you need two values, a "Start Date-Time" and an "End Date-Time", JavaScript Date objects that contain a time and date. We could use the following snippet of code to do this:

// create a new Date-Time object for the event start
var startDateTime = newDate(eventDate);
var startTimeHours = startTime.getHours();
var startTimeMinutes = startTime.getMinutes();
startDateTime.setHours(startTimeHours);
startDateTime.setMinutes(startTimeMinutes);

// create a new Date-Time object for the event end
var endDateTime = new Date(eventDate);
var endTimeHours = endTime.getHours();
var endTimeMinutes = endTime.getMinutes();
endDateTime.setHours(endTimeHours);
endDateTime.setMinutes(endTimeMinutes);

Now, we could use the two variables startDateTime and endDateTime when creating a Calendar event.

Now, we have enough pieces of the puzzle to be able to create a Google Calendar event using Apps Script. The CalendarApp allows you to work with Google Calendar, and the process is similar to working with other apps: you must get the calendar you want to create the event in using its ID, and then using the createEvent() command on that calendar, supplying the relevant information.

You can find the ID of a Google Calendar by going into Calendar's Settings, then selecting the calendar in question from the list on the left-hand side and scrolling down to the Integrate calendar section to find Calendar ID. For the main calendar connected to a Google account, this will be the email address of the user in question. Just like with a file or folder, store this ID in a variable in your Apps Script code, to use with the CalendarApp.getCalendarById() command.

// store calendar ID in a variable
var calendarID = 'test@gmail.com';

// get the calendar using its ID
var calendar = CalendarApp.getCalendarById(calendarId);

Once you have the calendar stored in a variable, you can do various things with that calendar, including using .createEvent() to make a calendar event. createEvent() needs an event title, a start date-time and an end date-time (see the previous heading in this box for how to get these), plus optionally additional options stored as a JavaScript object similarly to using sendEmail(). The options can include a description, location, guests, and whether invite emails are sent to any guests. You can read more about this on the Apps Script developers reference site section for createEvent().

You can create a calendar event without storing anything as a variable, or you can get the ID of the event, similarly to getting the ID of a document copy, so that you could write this back into a spreadsheet or store it in case the event needs to be accessed or deleted.

//create calendar event without variable
calendar.createEvent('My Event Title', startDateTime, endDateTime);

//create calendar event and store ID in a variable (and having event title as a separate variable)
var eventID = calendar.createEvent(eventTitle, startDateTime, endDateTime).getId();

//create calendar event with additional options
var eventDescription = "This will be a great event."
var location = "The big room";
var guests = "guest1@test.com,guest2@test.com";
var options = {'description':eventDescription,'location':location;'guests':guests,'sendInvites':true};
var eventID = calendar.createEvent(eventTitle, startDateTime, endDateTime, options).getId();

You may find that sometimes you don't quite get your event right the first time, which is why it can be useful to have the ID that you can then use to delete the event if you cannot find it manually in Google Calendar. The first date in JavaScript is January 1 1970 (as all dates are stored as a number of milliseconds after that date), so sometimes incorrectly set up calendar events will find themselves happening then!