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 trigger basato su eventi

Obiettivi

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

Informazioni su questa soluzione

Crea un sistema di registrazione agli eventi end-to-end. Se hai in programma un evento, ad esempio una conferenza, puoi configurare un nuovo calendario per le sessioni della conferenza, creare un modulo di registrazione e inviare automaticamente via email agli iscritti itinerari personalizzati.

Informazioni di Fogli trasferite a Moduli e Calendar

Come funziona

Questa soluzione utilizza un menu personalizzato in Fogli Google per implementare un sistema di registrazione agli eventi automatizzato. Lo script crea un calendario con gli eventi della conferenza elencati nel foglio di lavoro di Fogli. Poi, lo script crea un modulo con l'elenco degli eventi a cui gli iscritti possono registrarsi. Dopo che gli iscritti hanno compilato il modulo, lo script li aggiunge agli eventi del calendario e invia loro gli itinerari via email.

Servizi Apps Script

Questa soluzione utilizza i seguenti servizi:

Servizio foglio di lavoro: fornisce le informazioni sull'evento agli altri servizi.
Servizio Google Calendar: crea un nuovo calendario per l'evento, aggiunge eventi al calendario e aggiunge gli iscritti agli eventi a cui si registrano.
Servizio Proprietà: memorizza l' ID del calendario creato dal servizio Calendar. Quando un utente fa clic su Configura conferenza dal menu personalizzato Conferenza, il servizio Proprietà verifica se il sistema di registrazione agli eventi è già stato configurato controllando se è presente la proprietà ID calendario. In questo modo si evita la creazione di moduli e calendari duplicati.
Servizio Moduli Google: crea un modulo dalle informazioni nel foglio di lavoro che consente agli iscritti di registrarsi alle sessioni.
Servizio Script: crea un trigger che si attiva quando un partecipante compila il modulo.
Servizio Documenti: recupera le informazioni sull'evento per gli eventi a cui si registra un partecipante e aggiunge un elenco degli eventi a un nuovo documento. Lo script concede al partecipante l'autorizzazione a modificare il documento.
Servizio di posta: invia via email il documento dell'itinerario al partecipante.

Prerequisiti

Per utilizzare questo esempio, devi soddisfare i seguenti prerequisiti:

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

Configura lo script

Fai clic sul pulsante seguente per creare una copia del foglio di lavoro di Fogli di esempio Crea una registrazione per le sessioni di una conferenza. Il progetto Apps Script per questa soluzione è allegato al foglio di lavoro:

Crea una copia
Fai clic su Conferenza > Configura conferenza. Potresti dover aggiornare la pagina per visualizzare questo menu personalizzato.
Quando ti viene richiesto, autorizza lo script. <<../_snippets/oauth.md>>
Fai di nuovo clic su Conferenza > Configura conferenza.

Esegui lo script

Fai clic su Strumenti > Gestisci modulo > Vai al modulo live.
Compila e invia il modulo.
Vai a calendar.google.com.
A sinistra, assicurati che la casella accanto a Calendario della conferenza sia selezionata.
Vai alle date degli eventi a cui ti sei registrato e verifica di essere stato aggiunto come partecipante.

(Facoltativo) Reimposta la soluzione

Se vuoi riprovare questa soluzione o personalizzarla per utilizzare le tue informazioni sull'evento, devi reimpostare alcuni elementi configurati la prima volta che hai eseguito lo script. Per visualizzare i passaggi per reimpostare la soluzione, fai clic Reimposta la soluzione:

Reimposta la soluzione

Passaggio 1: reimposta le proprietà dello script memorizzate

Se provi a eseguire lo script più di una volta, ti verrà chiesto: La conferenza è già configurata. Cerca il modulo di registrazione in Google Drive. Questo accade perché una volta creato il calendario della conferenza, l'ID del calendario viene memorizzato come proprietà dello script. Quando lo script viene eseguito, verifica se la proprietà ID calendario esiste già e interrompe l'esecuzione in caso affermativo.

Per rimuovere la proprietà ID calendario esistente, segui questi passaggi:

Nel foglio di lavoro, fai clic su Estensioni > Apps Script.
Nell'editor di Apps Script, seleziona resetProperties dall'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 creato, segui questi passaggi:

Vai a calendar.google.com.
Accanto a Calendario della conferenza, fai clic su Opzioni per il calendario della conferenza > Impostazioni e condivisione.
Vai in fondo alle impostazioni e fai clic su Elimina.

Passaggio 3: elimina il trigger di invio del modulo

Lo script crea un trigger per gli invii di moduli ogni volta che lo esegui. Per evitare più trigger che generano email duplicate, rimuovi il trigger originale Procedi nel seguente modo:

Nel foglio di lavoro, fai clic su Estensioni > Apps Script.
Nel progetto Apps Script, a sinistra, fai clic su Trigger .
Accanto al trigger, fai clic su Altro > Elimina trigger.

Passaggio 4: scollega ed elimina il modulo

Ogni volta che esegui lo script, viene creato un nuovo modulo. Per scollegare il modulo dal foglio di lavoro ed eliminarlo, segui questi passaggi:

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

Una volta reimpostata la soluzione, puoi aggiungere i tuoi dati o continuare a utilizzare i dati di esempio ed eseguire di nuovo lo script.

Esamina il codice

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

Visualizza codice sorgente

Code.gs

solutions/automations/event-session-signup/Code.js

Visualizza su GitHub

// 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_() {
  const 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;
  }
  const ss = SpreadsheetApp.getActive();
  const sheet = ss.getSheetByName("Conference Setup");
  const range = sheet.getDataRange();
  const 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) {
  const cal = CalendarApp.createCalendar("Conference Calendar");
  // Start at 1 to skip the header row.
  for (let i = 1; i < values.length; i++) {
    const session = values[i];
    const title = session[0];
    const start = joinDateAndTime_(session[1], session[2]);
    const end = joinDateAndTime_(session[1], session[3]);
    const options = { location: session[4], sendInvites: true };
    const 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.
  const 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) {
  const processedDate = new Date(date_);
  processedDate.setHours(time.getHours());
  processedDate.setMinutes(time.getMinutes());
  return processedDate;
}

/**
 * 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.
  const schedule = {};
  // Start at 1 to skip the header row.
  for (let i = 1; i < values.length; i++) {
    const session = values[i];
    const day = session[1].toLocaleDateString();
    const 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.
  const form = FormApp.create("Conference Form");
  form.setDestination(FormApp.DestinationType.SPREADSHEET, ss.getId());
  form.addTextItem().setTitle("Name").setRequired(true);
  form.addTextItem().setTitle("Email").setRequired(true);
  for (const day of Object.keys(schedule)) {
    form.addSectionHeaderItem().setTitle(`Sessions for ${day}`);
    for (const time of Object.keys(schedule[day])) {
      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) {
  const 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.
  const response = [];
  const values = SpreadsheetApp.getActive()
    .getSheetByName("Conference Setup")
    .getDataRange()
    .getValues();
  for (let i = 1; i < values.length; i++) {
    const session = values[i];
    const title = session[0];
    const day = session[1].toLocaleDateString();
    const time = session[2].toLocaleTimeString();
    const 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) {
  const id = ScriptProperties.getProperty("calId");
  const 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) {
  const doc = DocumentApp.create(
    `Conference Itinerary for ${user.name}`,
  ).addEditor(user.email);
  const 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() {
  const scriptProperties = PropertiesService.getScriptProperties();
  scriptProperties.deleteAllProperties();
}

</section>

Collaboratori

Questo esempio è gestito da Google con l'aiuto di Esperti Google Developers.

Crea un'iscrizione alle sessioni di una conferenza Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.