Dans ce tutoriel, nous allons créer une application de rappel SMS avec node.js. Nous allons utiliser le calendrier Google de l'utilisateur pour obtenir des rendez-vous, puis envoyer le SMS avec Twilio.
Comme jamais, vous pouvez trouver le code utilisé dans ce tutoriel du repo github.
Vous devrez d'abord avoir un compte Google et un compte Twilio. Si vous n'en avez pas encore, vous pouvez aller de l'avant et vous inscrire. Voici les liens:
Vous n'avez pas à vous soucier de Twilio, c'est gratuit.
Une fois que vous avez un compte Google, accédez à la console Google et créez une nouvelle application. Par défaut, la page Google Console vous montre le tableau de bord de l'application la plus récente sur laquelle vous avez travaillé. Mais si vous ne travaillez pas encore sur des projets, cela montrera ce qui suit:
À partir de là, vous pouvez cliquer sur le menu Sélectionner le projet dans le coin supérieur droit et sélectionner Créer un projet. Cela ouvre une fenêtre modale qui vous permet d'entrer le titre du projet.
Une fois le projet créé, le tableau de bord s'affiche. À partir de là, vous pouvez cliquer sur les API Utiliser Google, rechercher l'API Google Calendar et l'activer.
Une fois l'API activé, il vous demandera de créer des informations d'identification. Cliquez sur Aller aux informations d'identification pour commencer à la configurer. Cela vous montrera ce qui suit:
Cliquez sur le bouton Ajouter des informations d'identification, puis sélectionnez ID Client OAuth 2.0.
Cela vous demandera d'abord de configurer l'écran de consentement. Cliquez sur Configurer l'écran de consentement.
Entrez une valeur pour le nom du produit indiqué au champ de texte des utilisateurs et cliquez sur Enregistrer.
Une fois que cela est configuré, vous pouvez désormais créer l'ID client. Sélectionnez l'application Web pour le type d'application, laissez le nom par défaut (si vous le souhaitez), entrez http: // localhost: 3000 / connexion pour les URI de redirection autorisés puis cliquez sur Créer.
Cela ouvre un modal qui affiche l'ID client et le secret du client. Prenez note de ceux pour l'instant car nous les utiliserons plus tard.
Une fois que vous avez créé un compte Twilio, accédez à la page des paramètres et prenez note des valeurs pour le compte et AuthToken sous les informations d'identification en direct.
Ensuite, allez au tableau de bord vocal programmable. C'est là que vous pouvez voir le numéro de bac à sable. Vous pouvez utiliser ce numéro pour tester Twilio. Mais plus tard, vous devrez acheter un numéro de téléphone afin que les messages texte envoyés par Twilio n'auront pas "envoyé à partir de Twilio Sandbox" l'a ajouté. Une autre limite du numéro de bac à sable Twilio est qu'elle ne peut être utilisée qu'avec des nombres vérifiés. Ce qui signifie que vous devez enregistrer un numéro de téléphone avec Twilio afin de lui envoyer un message. Vous pouvez le faire à partir de la page Gérer les ID de l'appelant.
Maintenant, nous sommes prêts à créer l'application. Avant de continuer, je voudrais donner un bref aperçu de la façon dont nous allons implémenter l'application. Il y aura trois fichiers principaux: un pour le serveur, un pour la mise en cache des événements de Google Calendar et un pour rappeler à l'utilisateur. Le serveur est utilisé pour permettre à l'utilisateur de se connecter et d'obtenir un jeton d'accès. Les événements seront enregistrés dans la base de données MySQL et la configuration de l'application globale sera ajoutée dans un fichier .json. La mise en œuvre de Node de CRON sera utilisée pour exécuter la tâche de mise en cache des événements et de rappeler à l'utilisateur.
Sur votre répertoire de travail, créez un fichier package.json et ajoutez ce qui suit:
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
Dans ce fichier, nous spécifions le nom et la version des bibliothèques dont dépend notre application. Voici une rupture d'utilisation pour chaque bibliothèque:
Exécuter l'installation de NPM à partir de votre terminal pour installer toutes les dépendances.
Comme mentionné précédemment, nous allons utiliser la base de données MySQL pour cette application. Allez-y et créez une nouvelle base de données à l'aide de l'outil de gestion de la base de données de votre choix. Utilisez ensuite le fichier SQL Dump suivant pour créer les tables: rendez-vous-notificier.sql.
Il y a deux tables dans la base de données: les utilisateurs et les rendez-vous. Le tableau des utilisateurs est utilisé pour stocker les données de l'utilisateur. Dans le cas de cette application, nous allons seulement stocker un seul utilisateur et seul le jeton d'accès est stocké.
Le tableau des rendez-vous est utilisé pour stocker les événements que nous avons obtenus de l'API Google Calendar. Notez qu'il n'y a pas de champ user_id car nous n'avons qu'un seul utilisateur. Et nous allons récupérer toutes les lignes qui ont zéro comme valeur pour le champ notifié.
Sur votre répertoire de travail, créez un dossier de configuration puis à l'intérieur, créez un fichier default.json. C'est là que nous allons mettre la configuration globale de l'application. Cela comprend le fuseau horaire, le numéro de téléphone auquel nous allons envoyer les rappels, la base de données, l'application Google et les paramètres Twilio.
Voici le modèle, assurez-vous de remplir tous les champs.
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
En tant que bons développeurs, nous devons éviter la répétition du code autant que possible. C'est pourquoi nous devons mettre du code nécessaire par ces trois fichiers principaux (serveur, cache, avis) que j'ai mentionné plus tôt dans des fichiers séparés. Créez un dossier commun sur votre répertoire de travail. C'est là que nous allons ajouter les fichiers communs.
Créer un fichier db.js à l'intérieur du répertoire commun, puis ajoutez ce qui suit:
{
"app": {
"timezone": "Asia/Manila"
},
"me": {
"phone_number": ""
},
"db": {
"host": "localhost",
"user": "root",
"password": "secret",
"database": "calendar_notifier"
},
"google":{
"client_id": "THE CLIENT ID OF YOUR GOOGLE APP",
"client_secret": "THE CLIENT SECRET OF YOUR GOOGLE APP",
"redirect_uri": "http://localhost:3000/login",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/calendar"
]
},
"twilio": {
"sid": "YOUR TWILIO SID",
"secret": "YOUR TWILIO SECRET",
"phone_number": "+YOUR TWILIO PHONE NUMBER / SANDBOX NUMBER"
}
}
Ceci utilise la bibliothèque de configuration pour obtenir les valeurs de configuration que nous avons ajoutées plus tôt sur le fichier config / default.json. Plus précisément, nous obtenons la configuration de la base de données afin que nous puissions nous connecter à la base de données. Ensuite, nous exportons ce module afin que nous puissions l'utiliser plus tard à partir d'un autre fichier.
Le fichier time.js est utilisé pour définir le fuseau horaire par défaut avec la bibliothèque Moment TimeZone. Nous exportons également la valeur du fuseau horaire car nous allons l'utiliser plus tard lors de l'exécution des deux tâches Cron (cache d'événements et notification des utilisateurs).
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
Le fichier Google.js est utilisé pour initialiser le client Google et le client OAuth2. Afin d'initialiser le client OAuth2, nous devons transmettre l'ID client, le secret du client et l'URL de redirection que nous avons ajouté dans le fichier de configuration plus tôt. Ensuite, nous initialisons le service de calendrier Google. Enfin, nous exportons le client OAuth2, le calendrier et la configuration Google.
{
"app": {
"timezone": "Asia/Manila"
},
"me": {
"phone_number": ""
},
"db": {
"host": "localhost",
"user": "root",
"password": "secret",
"database": "calendar_notifier"
},
"google":{
"client_id": "THE CLIENT ID OF YOUR GOOGLE APP",
"client_secret": "THE CLIENT SECRET OF YOUR GOOGLE APP",
"redirect_uri": "http://localhost:3000/login",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/calendar"
]
},
"twilio": {
"sid": "YOUR TWILIO SID",
"secret": "YOUR TWILIO SECRET",
"phone_number": "+YOUR TWILIO PHONE NUMBER / SANDBOX NUMBER"
}
}
Maintenant, nous sommes prêts à travailler sur le serveur. Le serveur est chargé d'obtenir le jeton d'accès. Qui peut être utilisé pour parler à l'API du calendrier Google sans que l'utilisateur soit actuellement connecté. Commencez par créer un fichier server.js et ajoutant ce qui suit:
var config = require('config');
var db_config = config.get('db');
var mysql = require('mysql');
var connection = mysql.createConnection({
host: db_config.host,
user: db_config.user,
password: db_config.password,
database: db_config.database
});
exports.db = connection;
le décomposant:
Nous importons d'abord le module Google et DB que nous avons créé plus tôt.
var config = require('config');
var app_timezone = config.get('app.timezone');
var moment = require('moment-timezone');
moment.tz.setDefault(app_timezone);
exports.config = {
timezone: app_timezone
};
exports.moment = moment;
Créez un serveur express qui s'exécute sur le port 3000 de LocalHost. C'est pourquoi nous avons ajouté http: // localhost: 3000 / connect plus tôt sur la configuration de l'application et dans l'uri de redirection pour google:
var config = require('config');
var google_config = config.get('google');
var google = require('googleapis');
var OAuth2 = google.auth.OAuth2;
var oauth2Client = new OAuth2(google_config.client_id, google_config.client_secret, google_config.redirect_uri);
var calendar = google.calendar('v3');
exports.oauth2Client = oauth2Client;
exports.calendar = calendar;
exports.config = google_config;
Définissez une fonction de mise à jour. Cela accepte deux arguments: les jetons et la réponse. Le jeton est le jeton d'accès que nous obtenons de Google après que l'utilisateur a donné les autorisations nécessaires. Et la réponse est l'objet de réponse qui vient d'Express. Nous le transmettons à cette fonction afin que nous puissions envoyer une réponse à l'utilisateur. À l'intérieur de la fonction, nous mettons à jour l'accès_token de la première ligne. Comme mentionné précédemment, cette application ne fonctionne que pour un seul utilisateur. Une fois l'accès_token mis à jour, nous envoyons la réponse.
var google = require('./common/google');
var connection = require('./common/db');
var express = require('express');
var app = express();
var server = app.listen(3000, function () {
var host = server.address().address;
var port = server.address().port;
console.log('Example app listening at http://%s:%s', host, port);
});
function updateAccessToken(tokens, response){
connection.db.query(
"UPDATE users SET access_token = ? WHERE id = 1",
[JSON.stringify(tokens)],
function(err, rows, fields){
if(!err){
console.log('updated!');
response.send('connected!');
}else{
console.log('error updating table');
console.log(err);
response.send('error occured, please try again');
}
}
);
}
app.get('/', function(req, res){
var url = google.oauth2Client.generateAuthUrl({
access_type: google.config.access_type,
scope: google.config.scopes
});
res.send('<a href="' + url + '">login to google</a>');
});
app.get('/login', function(req, res){
var code = req.query.code;
console.log('login');
google.oauth2Client.getToken(code, function(err, tokens){
if(!err){
console.log('tokens');
console.log(tokens);
updateAccessToken(tokens, res);
}else{
res.send('error getting token');
console.log('error getting token');
}
});
});
Ajoutez l'itinéraire pour la page d'accueil. Cela est exécuté lorsque http: // localhost: 3000 est accessible. De là, nous générons l'URL d'authentification. Cela utilise la méthode GenerateAuthurl de l'Oauth2Client. Il accepte un objet contenant l'accès_type et la portée. Nous obtenons ces valeurs du fichier de configuration de l'application que nous avons créé plus tôt. Enfin, nous envoyons le lien réel sur lequel l'utilisateur peut cliquer. Notez que vous devez toujours le faire dans une vue, mais pour simplifier les choses, nous allons simplement retourner directement le lien.
var google = require('./common/google');
var connection = require('./common/db');
Ajoutez l'itinéraire pour la connexion. Il s'agit de l'itinéraire où l'utilisateur est redirigé après avoir donné les autorisations nécessaires à l'application. Google passe dans un paramètre de requête appelé code. Et nous le recevons via l'objet de requête dans la demande. Nous appelons ensuite la méthode GetToken et passons dans le code comme argument. Cela nous donnerait le jeton d'accès. Nous appelons donc la fonction UpdateAccessToken pour l'enregistrer dans la base de données.
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
Le Cacher est responsable de l'enregistrement des rendez-vous des utilisateurs dans la base de données. Cela nous empêche d'avoir à interroger le répertoire de l'API Google Calendar à chaque fois que nous envoyons des rappels. Créez un fichier cache.js et ajoutez ce qui suit:
{
"app": {
"timezone": "Asia/Manila"
},
"me": {
"phone_number": ""
},
"db": {
"host": "localhost",
"user": "root",
"password": "secret",
"database": "calendar_notifier"
},
"google":{
"client_id": "THE CLIENT ID OF YOUR GOOGLE APP",
"client_secret": "THE CLIENT SECRET OF YOUR GOOGLE APP",
"redirect_uri": "http://localhost:3000/login",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/calendar"
]
},
"twilio": {
"sid": "YOUR TWILIO SID",
"secret": "YOUR TWILIO SECRET",
"phone_number": "+YOUR TWILIO PHONE NUMBER / SANDBOX NUMBER"
}
}
le décomposant:
Nous importons d'abord tous les modules dont nous avons besoin.
var config = require('config');
var db_config = config.get('db');
var mysql = require('mysql');
var connection = mysql.createConnection({
host: db_config.host,
user: db_config.user,
password: db_config.password,
database: db_config.database
});
exports.db = connection;
La fonction AddAppointment est responsable de la sauvegarde des rendez-vous dans le tableau des rendez-vous. Cela accepte l'événement_id, résumé, démarrage et fin de la nomination. L'événement_id est essentiellement l'ID de la nomination spécifique dans Google Calendar. Nous l'utilisons comme valeur de la clé principale, ce qui signifie que les doublons ne seront pas insérés dans le tableau des rendez-vous. Ce qui manque ici, ce sont les moyens de comparer les rendez-vous qui sont déjà dans la base de données et ceux renvoyés par l'API. Si, pour une raison quelconque, le calendrier du rendez-vous change, la base de données ne sera pas mise à jour car tout ce que nous faisons ici est d'insérer dans la table. Je vais laisser cela pour votre liste de tâches.
var config = require('config');
var app_timezone = config.get('app.timezone');
var moment = require('moment-timezone');
moment.tz.setDefault(app_timezone);
exports.config = {
timezone: app_timezone
};
exports.moment = moment;
La fonction GetEvents est responsable de la boucle via toutes les nominations renvoyées par l'API. Cela utilise la méthode AddAppOmingment pour enregistrer la nomination pour chaque itération de la boucle.
var config = require('config');
var google_config = config.get('google');
var google = require('googleapis');
var OAuth2 = google.auth.OAuth2;
var oauth2Client = new OAuth2(google_config.client_id, google_config.client_secret, google_config.redirect_uri);
var calendar = google.calendar('v3');
exports.oauth2Client = oauth2Client;
exports.calendar = calendar;
exports.config = google_config;
La méthode de cache est celle qui passe l'appel réel à l'API du calendrier Google. Ceci est via l'utilisation du client Google. Ici, nous appelons la méthode de la liste sur l'objet Calendar.Events. Cela accepte deux arguments: le premier est l'objet contenant les options de requête et la seconde est la fonction à exécuter une fois le résultat renvoyé.
var google = require('./common/google');
var connection = require('./common/db');
var express = require('express');
var app = express();
var server = app.listen(3000, function () {
var host = server.address().address;
var port = server.address().port;
console.log('Example app listening at http://%s:%s', host, port);
});
function updateAccessToken(tokens, response){
connection.db.query(
"UPDATE users SET access_token = ? WHERE id = 1",
[JSON.stringify(tokens)],
function(err, rows, fields){
if(!err){
console.log('updated!');
response.send('connected!');
}else{
console.log('error updating table');
console.log(err);
response.send('error occured, please try again');
}
}
);
}
app.get('/', function(req, res){
var url = google.oauth2Client.generateAuthUrl({
access_type: google.config.access_type,
scope: google.config.scopes
});
res.send('<a href="' + url + '">login to google</a>');
});
app.get('/login', function(req, res){
var code = req.query.code;
console.log('login');
google.oauth2Client.getToken(code, function(err, tokens){
if(!err){
console.log('tokens');
console.log(tokens);
updateAccessToken(tokens, res);
}else{
res.send('error getting token');
console.log('error getting token');
}
});
});
Dans l'objet contenant les options, nous avons ce qui suit:
Toutes ces options et bien d'autres peuvent être trouvées dans les événements: la documentation de la liste
Obtenez l'accès_token à partir de la base de données et utilisez-le pour définir les informations d'identification du client OAuth2Client. Une fois cela fait, créez un nouveau travail Cron qui exécutera la méthode de cache chaque jour à 12 minuit.
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
Enfin, nous avons le notificateur (notify.js). Ceci est chargé d'obtenir les rendez-vous de la base de données et de déterminer s'ils sont mûrs pour la notification. S'ils le sont, alors nous les envoyons.
{
"app": {
"timezone": "Asia/Manila"
},
"me": {
"phone_number": ""
},
"db": {
"host": "localhost",
"user": "root",
"password": "secret",
"database": "calendar_notifier"
},
"google":{
"client_id": "THE CLIENT ID OF YOUR GOOGLE APP",
"client_secret": "THE CLIENT SECRET OF YOUR GOOGLE APP",
"redirect_uri": "http://localhost:3000/login",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/calendar"
]
},
"twilio": {
"sid": "YOUR TWILIO SID",
"secret": "YOUR TWILIO SECRET",
"phone_number": "+YOUR TWILIO PHONE NUMBER / SANDBOX NUMBER"
}
}
le décomposant:
Importez tous les modules requis.
var config = require('config');
var db_config = config.get('db');
var mysql = require('mysql');
var connection = mysql.createConnection({
host: db_config.host,
user: db_config.user,
password: db_config.password,
database: db_config.database
});
exports.db = connection;
Créez une fonction de mise à jour de mise à jour. Cela accepte l'ID de la nomination comme son argument. Tout ce qu'il fait est de définir la valeur du champ notifié sur 1, ce qui signifie que la notification de la nomination spécifique a déjà été envoyée.
var config = require('config');
var app_timezone = config.get('app.timezone');
var moment = require('moment-timezone');
moment.tz.setDefault(app_timezone);
exports.config = {
timezone: app_timezone
};
exports.moment = moment;
Ensuite, nous avons la fonction SendNotifications. Ceci est responsable de l'envoi des rappels de texte avec Twilio. Cette fonction est appelée après avoir obtenu les rendez-vous à partir de la base de données. C’est pourquoi il a l’erreur, les résultats et les arguments des champs qui y sont passés. L'erreur contient toute erreur de la base de données. Les résultats contiennent les lignes renvoyées de la base de données. Et les champs contiennent des informations sur les champs de résultats renvoyés.
var config = require('config');
var google_config = config.get('google');
var google = require('googleapis');
var OAuth2 = google.auth.OAuth2;
var oauth2Client = new OAuth2(google_config.client_id, google_config.client_secret, google_config.redirect_uri);
var calendar = google.calendar('v3');
exports.oauth2Client = oauth2Client;
exports.calendar = calendar;
exports.config = google_config;
À l'intérieur de la fonction, nous obtenons le numéro de téléphone des utilisateurs à partir de la configuration de l'application.
{
"name": "google-calendar-twilio",
"version": "0.0.1",
"dependencies": {
"config": "^1.17.1",
"cron": "^1.1.0",
"express": "^4.13.3",
"googleapis": "^2.1.6",
"moment": "^2.10.6",
"moment-timezone": "^0.4.1",
"mysql": "felixge/node-mysql",
"twilio": "^2.6.0"
}
}
Vérifiez s'il y a des erreurs et s'il n'y en a pas, procédez en boucle via tous les résultats qui ont été renvoyés.
{
"app": {
"timezone": "Asia/Manila"
},
"me": {
"phone_number": ""
},
"db": {
"host": "localhost",
"user": "root",
"password": "secret",
"database": "calendar_notifier"
},
"google":{
"client_id": "THE CLIENT ID OF YOUR GOOGLE APP",
"client_secret": "THE CLIENT SECRET OF YOUR GOOGLE APP",
"redirect_uri": "http://localhost:3000/login",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/calendar"
]
},
"twilio": {
"sid": "YOUR TWILIO SID",
"secret": "YOUR TWILIO SECRET",
"phone_number": "+YOUR TWILIO PHONE NUMBER / SANDBOX NUMBER"
}
}
À l'intérieur de la boucle, nous extraissons toutes les valeurs dont nous avons besoin et construisons le message réel à envoyer. Nous obtenons également la différence d'heure entre l'heure actuelle et l'heure de début du rendez-vous. Nous vérifions si la différence heure est inférieure ou égale à 24 heures.
var config = require('config');
var db_config = config.get('db');
var mysql = require('mysql');
var connection = mysql.createConnection({
host: db_config.host,
user: db_config.user,
password: db_config.password,
database: db_config.database
});
exports.db = connection;
Si c'est inférieur ou égal à 24 heures, nous envoyons la notification. Ceci est grâce à l'utilisation du client Twilio. Nous appelons SendMessage et passons dans un objet contenant le TO (le numéro de téléphone des utilisateurs), à partir de (numéro Sandobox de Twilio ou un numéro de téléphone que vous avez acheté auprès de Twilio), et le corps qui contient le SMS. S'il n'y a pas d'erreurs renvoyées, nous supposons que la notification a été envoyée. Nous appelons donc la fonction UpdateAPpointment pour définir le champ notifié sur 1, il ne sera donc pas sélectionné la prochaine fois que la tâche s'exécutera.
var config = require('config');
var app_timezone = config.get('app.timezone');
var moment = require('moment-timezone');
moment.tz.setDefault(app_timezone);
exports.config = {
timezone: app_timezone
};
exports.moment = moment;
Enfin, nous avons la méthode StartTask. Tout ce qu'il fait est de sélectionner tous les rendez-vous dans le tableau des rendez-vous dont la notification n'a pas encore été envoyée. Cette fonction est exécutée toutes les 12 h et 18 h
var config = require('config');
var google_config = config.get('google');
var google = require('googleapis');
var OAuth2 = google.auth.OAuth2;
var oauth2Client = new OAuth2(google_config.client_id, google_config.client_secret, google_config.redirect_uri);
var calendar = google.calendar('v3');
exports.oauth2Client = oauth2Client;
exports.calendar = calendar;
exports.config = google_config;
c'est tout! Dans ce tutoriel, vous avez appris à créer une application de rappel SMS avec Twilio. Plus précisément, nous avons examiné comment obtenir les rendez-vous de l'utilisateur via l'API Google Calendar. Nous avons enregistré ceux-ci dans la base de données et informé l'utilisateur via Twilio. Vous pouvez trouver le code utilisé dans ce tutoriel à partir du dépôt GitHub.
Tester la fonctionnalité de votre application de rappel de rendez-vous SMS est cruciale pour s'assurer qu'elle fonctionne comme prévu. Vous pouvez utiliser les outils de test intégrés de Twilio pour simuler des messages d'envoi et de réception. Vous pouvez également utiliser des cadres de test unitaires comme Jest ou Mocha pour votre code JavaScript. N'oubliez pas de tester toutes les fonctionnalités, y compris la création de rendez-vous, la planification du rappel et l'envoi de SMS.
Oui, vous pouvez personnaliser les messages de rappel dans votre application . Le contenu du message est généralement défini dans votre code côté serveur. Vous pouvez le modifier pour inclure toutes les informations que vous souhaitez, telles que l'heure de rendez-vous, l'emplacement ou tout autre détail pertinent pour le rendez-vous.
La planification des rappels pour différents fuseaux horaires peut être un peu délicat. Vous devez stocker les informations de fuseau horaire pour chaque rendez-vous et l'utiliser lors de la planification des rappels. L'objet Date de JavaScript peut gérer les conversions de fuseau horaire, ou vous pouvez utiliser des bibliothèques comme Moment.js pour des scénarios plus complexes.
Si un SMS ne parvient pas, Twilio tentera de le renvoyer. Vous pouvez également configurer la gestion des erreurs dans votre code pour enregistrer ces défaillances et prendre des mesures appropriées, telles que la redressement du message ou la notification de l'utilisateur.
Oui, vous pouvez utiliser cette application pour plusieurs utilisateurs. Vous devrez modifier le code pour associer des rendez-vous avec des utilisateurs spécifiques et vous assurer que les rappels sont envoyés au numéro de téléphone correct. Cela peut impliquer l'ajout d'authentification des utilisateurs et la gestion des données des utilisateurs dans votre base de données.
La sécurité de vos données dépend de la façon dont vous implémentez votre application. Twilio fournit des canaux de communication sécurisés, mais vous devez également vous assurer que votre serveur et votre base de données sont sécurisés. Cela peut impliquer l'utilisation de protocoles sécurisés, le cryptage des données sensibles et suivre les meilleures pratiques pour la sécurité Web.
Oui, vous pouvez intégrer cette application avec votre système de planification existant. Cela impliquerait de modifier le code pour interagir avec l'API ou la base de données de votre système. Les détails exacts dépendraient des spécificités de votre système de planification.
Le coût de l'envoi de rappels SMS avec Twilio dépend du nombre de Messages que vous envoyez et les pays auxquels vous les envoyez. Twilio fournit une structure de tarification détaillée sur leur site Web.
Oui, vous pouvez envoyer des rappels à des numéros internationaux avec Twilio. Cependant, vous devez vous assurer que vous êtes conforme aux réglementations SMS dans chaque pays, et le coût peut être plus élevé que pour les messages domestiques.
Vous pouvez surveiller les performances de votre application à l'aide de divers outils. Twilio fournit des analyses pour votre utilisation SMS et vous pouvez utiliser des outils de surveillance du serveur pour suivre les performances de votre code côté serveur. Vous devez également mettre en œuvre la journalisation pour aider à diagnostiquer tous les problèmes qui surviennent.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
