Crea un'iscrizione alle sessioni di una conferenza

Livello di programmazione: Principiante
Durata: 5 minuti
Tipo di progetto: automazione con un menu personalizzato e un attivatore basato su eventi

Obiettivi

  • Comprendi cosa fa la soluzione.
  • Scopri cosa fanno i servizi Apps Script all'interno soluzione.
  • Configura lo script.
  • Esegui lo script.

Informazioni su questa soluzione

Creare un sistema di registrazione agli eventi end-to-end. Se hai un evento come una conferenza, puoi impostare un nuovo calendario per sessioni, creare un modulo di iscrizione e inviare automaticamente via email ai partecipanti un'email personalizzata itinerari.

Informazioni da Fogli trasferite a Moduli e Calendar

Come funziona

Questa soluzione utilizza un menu personalizzato in Fogli Google per implementare un'impostazione di registrazione a eventi. Lo script crea un calendario con la conferenza eventi elencati nel foglio di lavoro di Fogli. Quindi, lo script crea un modulo con l'elenco degli eventi a cui i partecipanti possono iscriversi. Dopo i partecipanti il modulo, lo script aggiunge i partecipanti agli eventi nel calendario e invia loro gli itinerari via email.

Servizi Apps Script

Questa soluzione utilizza i seguenti servizi:

  • Servizio fogli di lavoro: fornisce la informazioni sugli eventi agli altri servizi.
  • Servizio Calendar: crea un nuovo calendario per l'evento, aggiunge eventi al calendario e altri partecipanti agli eventi a cui si iscrivono.
  • Servizio proprietà: archivia il ID del calendario creato dal servizio Calendar. Quando un utente fa clic su Configura conferenza dal menu Conferenza personalizzato, Il servizio proprietà controlla se il sistema di registrazione degli eventi ha già è stato configurato controllando se è presente la proprietà dell'ID calendario. Ciò aiuta evitare la creazione di moduli e calendari duplicati.
  • Servizio moduli: crea un modulo dalle informazioni del foglio di lavoro che consentono ai partecipanti di registrarsi sessioni.
  • Servizio di script: crea un trigger che si attiva quando un partecipante compila il modulo.
  • Servizio documenti: ottiene l'evento le informazioni sugli eventi a cui un partecipante si iscrive e aggiunge un elenco eventi in un nuovo documento. Lo script concede al partecipante l'autorizzazione a modificare del documento.
  • Servizio di posta: invia il documento dell'itinerario via email a il partecipante.

Prerequisiti

Per utilizzare questo esempio, sono necessari i seguenti prerequisiti:

  • Un Account Google (gli account Google Workspace possono richiedono l'approvazione dell'amministratore).
  • Un browser web con accesso a internet.

Configurare lo script

  1. Fai clic sul pulsante seguente per creare una copia del documento Crea una registrazione per fogli di lavoro di esempio durante una conferenza. Apps Script progetto per questa soluzione è allegato al foglio di lavoro.
    Crea una copia
  2. Fai clic su Conferenza > Configura. conferenza. Potresti dover aggiornare la pagina per visualizzare questo menu personalizzato vengono visualizzate.

  3. Quando richiesto, autorizza lo script. Se nella schermata per il consenso OAuth viene visualizzato l'avviso Questa app non è stata verificata. continua selezionando Avanzate > Vai a {Project Name} (non sicuro).

  4. Fai clic su Conferenza > Configura. conferenza.

Esegui lo script

  1. Fai clic su Strumenti > Gestisci modulo. > Vai al modulo online.
  2. Compila e invia il modulo.
  3. Vai a calendar.google.com.
  4. A sinistra, assicurati che la casella accanto a Calendario conferenze sia selezionata.
  5. Vai alle date degli eventi a cui hai effettuato la registrazione e conferma di essere stato aggiunto come partecipante.

(Facoltativo) Reimposta la soluzione

Se vuoi riprovare questa soluzione, oppure personalizzala per utilizzare le tue informazioni sugli eventi, devi reimpostare alcuni elementi configurati quando hai eseguito lo script per la prima volta. Per visualizzare i passaggi per reimpostare la soluzione, fai clic su Reimposta la soluzione di seguito:

Reimposta la soluzione

Passaggio 1: reimposta le proprietà degli script archiviate

Se tenti di eseguire lo script più di una volta, verrà visualizzato il messaggio Il tuo La conferenza è già configurata. Cerca il modulo di registrazione su Google Drive. Questo accade perché, una volta creato il calendario della conferenza, l'ID calendario viene archiviata come proprietà di script. Durante l'esecuzione, lo script controlla se La proprietà ID calendario esiste già e, in caso affermativo, smette di essere eseguita.

Per rimuovere la proprietà dell'ID calendario esistente:

  1. Nel foglio di lavoro, fai clic su Estensioni. > Apps Script.
  2. Nell'editor di Apps Script, seleziona resetProperties dalla dell'elenco a discesa delle funzioni e fai clic su Esegui.

Passaggio 2: elimina il calendario della conferenza

Ogni volta che lo script viene eseguito, crea un nuovo calendario. Se non vuoi conservare il calendario originale che è stato creato, attieniti alla seguente procedura:

  1. Vai a calendar.google.com.
  2. Accanto a Calendario conferenze, fai clic su Opzioni per Calendario conferenze > Impostazioni e condivisione.
  3. Scorri fino in fondo alle impostazioni e fai clic su Elimina.

Passaggio 3: elimina l'attivatore di invio del modulo

Lo script crea un trigger per l'invio di un modulo ogni volta che lo esegui. A evitare più attivatori che comportano email duplicate, rimuovi l'originale trigger. Segui questi passaggi:

  1. Nel foglio di lavoro, fai clic su Estensioni. > Apps Script.
  2. Nel progetto Apps Script, a sinistra, fai clic su Trigger .
  3. Accanto all'attivatore, fai clic su Altro . > Elimina trigger.

Ogni volta che lo esegui, lo script crea un nuovo modulo. Segui questi passaggi per scollega il modulo dal foglio di lavoro ed eliminalo:

  1. Nel foglio di lavoro, fai clic con il pulsante destro del mouse sul foglio Risposte del modulo e fai clic su. Scollega modulo > Ok.
  2. Fai di nuovo clic con il tasto destro del mouse sul foglio Risposte del modulo e fai clic su Elimina. > OK.
  3. Vai a forms.google.com.
  4. Fai clic con il pulsante destro del mouse su Modulo conferenza e fai clic su Rimuovi > Sposta nel cestino.

Dopo aver reimpostato la soluzione, puoi aggiungere i tuoi dati o continuare con utilizzare i dati di esempio ed eseguire nuovamente lo script.

Esamina il codice

Per esaminare il codice Apps Script per questa soluzione, fai clic su Visualizza il codice sorgente di seguito:

Visualizza codice sorgente

Code.gs

solutions/automations/event-session-signup/Code.js
// To learn how to use this script, refer to the documentation:
// https://developers.google.com/apps-script/samples/automations/event-session-signup

/*
Copyright 2022 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/**
 * Inserts a custom menu when the spreadsheet opens.
 */
function onOpen() {
  SpreadsheetApp.getUi().createMenu('Conference')
      .addItem('Set up conference', 'setUpConference_')
      .addToUi();
}

/**
 * Uses the conference data in the spreadsheet to create
 * Google Calendar events, a Google Form, and a trigger that allows the script
 * to react to form responses.
 */
function setUpConference_() {
  let scriptProperties = PropertiesService.getScriptProperties();
  if (scriptProperties.getProperty('calId')) {
    Browser.msgBox('Your conference is already set up. Look in Google Drive for your'
                   + ' sign-up form!');
                   return;
  }
  let ss = SpreadsheetApp.getActive();
  let sheet = ss.getSheetByName('Conference Setup');
  let range = sheet.getDataRange();
  let values = range.getValues();
  setUpCalendar_(values, range);
  setUpForm_(ss, values);
  ScriptApp.newTrigger('onFormSubmit').forSpreadsheet(ss).onFormSubmit()
      .create();
}

/**
 * Creates a Google Calendar with events for each conference session in the
 * spreadsheet, then writes the event IDs to the spreadsheet for future use.
 * @param {Array<string[]>} values Cell values for the spreadsheet range.
 * @param {Range} range A spreadsheet range that contains conference data.
 */
function setUpCalendar_(values, range) {
  let cal = CalendarApp.createCalendar('Conference Calendar');
  // Start at 1 to skip the header row.
  for (let i = 1; i < values.length; i++) {
    let session = values[i];
    let title = session[0];
    let start = joinDateAndTime_(session[1], session[2]);
    let end = joinDateAndTime_(session[1], session[3]);
    let options = {location: session[4], sendInvites: true};
    let event = cal.createEvent(title, start, end, options)
        .setGuestsCanSeeGuests(false);
    session[5] = event.getId();
  }
  range.setValues(values);

  // Stores the ID for the Calendar, which is needed to retrieve events by ID.
  let scriptProperties = PropertiesService.getScriptProperties();
  scriptProperties.setProperty('calId', cal.getId());
}

/**
 * Creates a single Date object from separate date and time cells.
 *
 * @param {Date} date A Date object from which to extract the date.
 * @param {Date} time A Date object from which to extract the time.
 * @return {Date} A Date object representing the combined date and time.
 */
function joinDateAndTime_(date, time) {
  date = new Date(date);
  date.setHours(time.getHours());
  date.setMinutes(time.getMinutes());
  return date;
}

/**
 * Creates a Google Form that allows respondents to select which conference
 * sessions they would like to attend, grouped by date and start time in the
 * caller's time zone.
 *
 * @param {Spreadsheet} ss The spreadsheet that contains the conference data.
 * @param {Array<String[]>} values Cell values for the spreadsheet range.
 */
function setUpForm_(ss, values) {
  // Group the sessions by date and time so that they can be passed to the form.
  let schedule = {};
  // Start at 1 to skip the header row.
  for (let i = 1; i < values.length; i++) {
    let session = values[i];
    let day = session[1].toLocaleDateString();
    let time = session[2].toLocaleTimeString();
    if (!schedule[day]) {
      schedule[day] = {};
    }
    if (!schedule[day][time]) {
      schedule[day][time] = [];
    }
    schedule[day][time].push(session[0]);
  }

  // Creates the form and adds a multiple-choice question for each timeslot.
  let form = FormApp.create('Conference Form');
  form.setDestination(FormApp.DestinationType.SPREADSHEET, ss.getId());
  form.addTextItem().setTitle('Name').setRequired(true);
  form.addTextItem().setTitle('Email').setRequired(true);
  Object.keys(schedule).forEach(function(day) {
    let header = form.addSectionHeaderItem().setTitle('Sessions for ' + day);
    Object.keys(schedule[day]).forEach(function(time) {
      let item = form.addMultipleChoiceItem().setTitle(time + ' ' + day)
          .setChoiceValues(schedule[day][time]);
    });
  });
}

/**
 * Sends out calendar invitations and a
 * personalized Google Docs itinerary after a user responds to the form.
 *
 * @param {Object} e The event parameter for form submission to a spreadsheet;
 *     see https://developers.google.com/apps-script/understanding_events
 */
function onFormSubmit(e) {
  let user = {name: e.namedValues['Name'][0], email: e.namedValues['Email'][0]};

  // Grab the session data again so that we can match it to the user's choices.
  let response = [];
  let values = SpreadsheetApp.getActive().getSheetByName('Conference Setup')
      .getDataRange().getValues();
  for (let i = 1; i < values.length; i++) {
    let session = values[i];
    let title = session[0];
    let day = session[1].toLocaleDateString();
    let time = session[2].toLocaleTimeString();
    let timeslot = time + ' ' + day;

    // For every selection in the response, find the matching timeslot and title
    // in the spreadsheet and add the session data to the response array.
    if (e.namedValues[timeslot] && e.namedValues[timeslot] == title) {
      response.push(session);
    }
  }
  sendInvites_(user, response);
  sendDoc_(user, response);
}

/**
 * Add the user as a guest for every session he or she selected.
 * @param {object} user An object that contains the user's name and email.
 * @param {Array<String[]>} response An array of data for the user's session choices.
 */
function sendInvites_(user, response) {
  let id = ScriptProperties.getProperty('calId');
  let cal = CalendarApp.getCalendarById(id);
  for (let i = 0; i < response.length; i++) {
    cal.getEventSeriesById(response[i][5]).addGuest(user.email);
  }
}

/**
 * Creates and shares a personalized Google Doc that shows the user's itinerary.
 * @param {object} user An object that contains the user's name and email.
 * @param {Array<string[]>} response An array of data for the user's session choices.
 */
function sendDoc_(user, response) {
  let doc = DocumentApp.create('Conference Itinerary for ' + user.name)
      .addEditor(user.email);
  let body = doc.getBody();
  let table = [['Session', 'Date', 'Time', 'Location']];
  for (let i = 0; i < response.length; i++) {
    table.push([response[i][0], response[i][1].toLocaleDateString(),
      response[i][2].toLocaleTimeString(), response[i][4]]);
  }
  body.insertParagraph(0, doc.getName())
      .setHeading(DocumentApp.ParagraphHeading.HEADING1);
  table = body.appendTable(table);
  table.getRow(0).editAsText().setBold(true);
  doc.saveAndClose();

  // Emails a link to the Doc as well as a PDF copy.
  MailApp.sendEmail({
    to: user.email,
    subject: doc.getName(),
    body: 'Thanks for registering! Here\'s your itinerary: ' + doc.getUrl(),
    attachments: doc.getAs(MimeType.PDF),
  });
}

/**
 * Removes the calId script property so that the 'setUpConference_()' can be run again.
 */
function resetProperties(){
  let scriptProperties = PropertiesService.getScriptProperties();
  scriptProperties.deleteAllProperties();
}

Collaboratori

Questo campione è gestito da Google con l'aiuto degli Esperti Google Developers.

Passaggi successivi