Alertes cryptomonnaies par SMS avec JavaScript, Node.js et Twilio

git clone git@github.com:ssenkus/coin-sms-alert.git

git checkout step-1-simple-express-app; npm install

mkdir coin-sms-alert; cd coin-sms-alert

npm init -y

npm install -save express

// server.js
const express = require('express');
const app = express();

// Requests to http://localhost:3000/ will respond with a JSON object
app.get('/', (req, res) => {
   res.json({success: true});
});

// Start listening on port 3000 to start receiving requests
app.listen(3000, () => {
   console.log('Example app listening on port 3000!')
});

npm start

git checkout step-2-retrieving-cryptocurrency-data; npm install

npm install --save request

// server.js

const express = require('express');
const bodyParser = require('body-parser');
const request = require('request');
const app = express();

// Use body-parser as middleware so that we have JSON data available on Request objects
app.use(bodyParser.json({type: 'application/json'}));

// Requests to http://localhost:3000/ will respond with a JSON object
app.get('/', (req, res) => {
   res.json({success: true});
});

// Requests to http://localhost:3000/api/coins will trigger a request to CoinMarketCap API,
// respond with a JSON object with coin prices, and log a message to the console.
app.get('/api/coins', (req, res) => {
   request.get('https://api.coinmarketcap.com/v1/ticker/', (err, response, body) => {
       let coinData = JSON.parse(body);

       console.log(coinData);
       res.json(coinData);
   });
});

// Start listening on port 3000 to start receiving requests
app.listen(3000, () => {
   console.log('Coin Alert app listening on port 3000!')
});

git checkout step-3-simple-alarm; npm install

npm install --save underscore

// models/alarm.js
const _ = require('underscore');

class Alarm {

   constructor(data) {
       // put data object onto Alarm object
       _.extend(this, data);
   }

   // Returns a boolean based on whether alarm threshold has been exceeded
   isTriggered(latestCoinData) {
       let isAlarmTriggered = false;
       switch (this.thresholdDirection) {
           case 'under':
               isAlarmTriggered = latestCoinData.price_usd < this.priceUsdThreshold; break; case 'over': default: isAlarmTriggered = latestCoinData.price_usd > this.priceUsdThreshold;
               break;
       }
       return isAlarmTriggered;
   }
}

module.exports = Alarm;

// server.js

const express = require('express');
const bodyParser = require('body-parser');
const request = require('request');
const _ = require('underscore');
// Import our new Alarm model
const Alarm = require('./models/alarm');

const app = express();


app.use(bodyParser.json({type: 'application/json'}));

// Requests to http://localhost:3000/ will respond with a JSON object
app.get('/', (req, res) => {
   res.json({success: true});
});

// Requests to http://localhost:3000/api/coins will trigger a request to CoinMarketCap API,
// respond with a JSON object with coin prices, and log a message to the console if Bitcoin is above $1000.
app.get('/api/coins', (req, res) => {
   request.get('https://api.coinmarketcap.com/v1/ticker/', (err, response, body) => {
       let coinsData = JSON.parse(body);

       // Hardcode an Alarm with a low value to ensure alarm will trigger
       let alarm = new Alarm({
           coinId: 'bitcoin',
           priceUsdThreshold: 1000.00,
           thresholdDirection: 'over'
       });

       // Find Bitcoin's data object inside response collection
       let latestCoinData = _.findWhere(coinsData, { id: alarm.coinId});

       //  Log the alarm data to the console if the threshold is crossed
       if (latestCoinData && alarm.isTriggered(latestCoinData)) {
           console.log(`* ALARM * ${alarm.coinId}: $${latestCoinData.price_usd} is ${ alarm.thresholdDirection} threshold $${alarm.priceUsdThreshold}`);
       }
       // Return a JSON object of the CoinMarketCap API response
       res.json(coinsData);
   });
});

// Start listening on port 3000 to start receiving requests
app.listen(3000, () => {
   console.log('Coin Alert app listening on port 3000!')
});

npm start

git checkout step-4-save-alarm-mongodb; npm install

mongod

npm install --save mongodb

// mongoClientWrapper.js
const mongoClient = require('mongodb').MongoClient;

let db = null;
let dbConnectionString = 'mongodb://localhost:27017';
let dbName = 'coin-sms-alert';

// Connect to our MongoDB database and make database client available for use
exports.initialize = (done) => {
   if (db) return process.nextTick(done);

   console.log('Connecting to mongo database: ' + dbConnectionString);

   mongoClient.connect(dbConnectionString, (err, connectedDb) => {
       if (err) {
           console.log('Couldn\'t connect to mongo database', err);
           return done(err);
       }

       db = connectedDb.db(dbName);
       return done();
   });
};

// Close our MongoDB connection for shutdown
exports.dispose = (done) => {
   if (db) {
       console.log('Closing connection to mongo database: ' + dbConnectionString);
       var tempDb = db;
       db = null;
       tempDb.close((err, result) => {
           if (err) {
               console.log('Error closing connection to mongo database', err);
               return done(err);
           }
           console.log('Database connection closed');
           return done();
       });
   } else {
       return process.nextTick(done);
   }
};

exports.getDb = () => {
   return db;
};

exports.alarms = () => {
   return db.collection('alarms');
};

const coinDataRoutes = require('./coinDataRoutes');
const alarmRoutes = require('./alarmRoutes');

// Configure all routes here
exports.configure = (app) => {

   // Test URL
   app.get('/', (req, res) => {
       res.json({success: true});
   });

   // Add routes to the express app object
   coinDataRoutes.configure(app);
   alarmRoutes.configure(app);

};

const alarmRepo = require('../dataAccess/repos/alarmRepository');

// Alarm CRUD (CREATE - READ/RETRIEVE - UPDATE - DELETE) routes
exports.configure = (app) => {
   // RESTful routing
   app.post('/api/alarm', createAlarm);
   app.get('/api/alarm', getAlarms);

};

// Create an alarm and respond with JSON alarm object
function createAlarm(req, res, done) {
   const alarmData = req.body;

   alarmRepo.createAlarm(alarmData, (err, alarm) => {
       return res.json(alarm);
   });
}

// Retrieve all alarms and return a JSON array
function getAlarms(req, res, done) {

   alarmRepo.getAlarms((err, alarms) => {
       return res.json(alarms);
   });

}

const _ = require('underscore');

const coinDataRepo = require('../dataAccess/repos/coinDataRepository');
const alarmRepo = require('../dataAccess/repos/alarmRepository');

// Coin routes
exports.configure = (app) => {
   // RESTful coin routes
   app.get('/api/coins', getCoinData);

};

// Get latest coin data, get all created alarms,
// determine if any alarms have thresholds that have been crossed,
// return coin data in JSON format
function getCoinData(req, res, done) {

   coinDataRepo.getCoinData((err, coinsData) => {

       alarmRepo.getAlarms((err, alarms) => {

           alarms.forEach((alarm) => {

               let latestCoinData = _.findWhere(coinsData, {id: alarm.coinId});

               if (latestCoinData && alarm.isTriggered(latestCoinData)) {
                   console.log(`* ALARM * ${alarm.coinId}: $${latestCoinData.price_usd} is ${ alarm.thresholdDirection} threshold $${alarm.priceUsdThreshold}`);
               }

           });

           res.json(coinsData);
       });

   });

}

const Alarm = require('../../models/alarm');
const db = require('../../dataAccess/mongoClientWrapper');

// Insert an alarm document record in MongoDB alarms collection
exports.createAlarm = (alarmData, done) => {
   const collection = db.alarms();

   collection.insertOne(alarmData, (err, alarm) => {
       done(err, alarm);
   });
};

// Retrieve all alarms from MongoDB alarm collection, convert all to Alarm model objects
exports.getAlarms = (done) => {
   const collection = db.alarms();

   collection.find({}).toArray((err, results) => {
       let alarms = results.map((result) => {
           return new Alarm(result)
       });

       done(err, alarms);
   });
};

const request = require('request');

// Make a GET request to CoinMarketCap's API to retrieve latest cryptocoin prices
exports.getCoinData = (done) => {

   request.get('https://api.coinmarketcap.com/v1/ticker/', (err, response, body) => {

       let coinsData = JSON.parse(body);

       done(err, coinsData);
   });

};

const express = require('express');
const bodyParser = require('body-parser');

const routes = require('./routes/routes');
const mongoClientWrapper = require('./dataAccess/mongoClientWrapper');
const app = express();

// Use body-parser as middleware so that we have JSON data available on Request objects
app.use(bodyParser.json({type: 'application/json'}));

// Start listening on port 3000 to start receiving requests
app.listen(3000, () => {
   console.log('Coin Alert app listening on port 3000!');

   // Initialize our MongoDB client
   mongoClientWrapper.initialize(() => {
       // Set up routes
       routes.configure(app);
   });

});

git checkout step-5-send-sms-alarms; npm install

npm install --save dotenv

TWILIO_ACCOUNT_SID=yourAccountSid
TWILIO_AUTH_TOKEN=yourAuthToken
FROM_PHONE_NUMBER=yourTwilioPhoneNumber
TO_PHONE_NUMBER=yourPersonalSmsEnabledPhoneNumber

npm install --save twilio

const dotenv = require('dotenv');
const Twilio = require('twilio');

const config = dotenv.config().parsed;
const client = new Twilio(config.TWILIO_ACCOUNT_SID, config.TWILIO_AUTH_TOKEN);


exports.sendSms = (bodyMessage, done) => {

   let message = {
       to: config.TO_PHONE_NUMBER,
       from: config.FROM_PHONE_NUMBER,
       body: bodyMessage
   };

   client.messages.create(message, (err, message) => {
       if (err) return done(err);

       return done(null, message);
   });

};

const smsService = require('../services/smsService');

// SMS-related routes
exports.configure = (app) => {
   // Test route to ensure API successfully sends a SMS alarm to our phone
   app.get('/api/sms/test', sendSmsTest);

};

// Send an SMS test message
function sendSmsTest(req, res, done) {

   smsService.sendSms('This is a test message from our Node.js App!', () => {
       console.log('Successfully sent a SMS message');

       res.json({
           success: true
       });
   })

}

const coinDataRoutes = require('./coinDataRoutes');
const alarmRoutes = require('./alarmRoutes');
const smsRoutes = require('./smsRoutes');

// Configure all routes here
exports.configure = (app) => {

   // Test URL
   app.get('/', (req, res) => {
       res.json({success: true});
   });

   // Add routes to the express app object
   coinDataRoutes.configure(app);
   alarmRoutes.configure(app);
   smsRoutes.configure(app);

};

const _ = require('underscore');

const coinDataRepo = require('../dataAccess/repos/coinDataRepository');
const alarmRepo = require('../dataAccess/repos/alarmRepository');
const smsService = require('../services/smsService');

// Coin routes
exports.configure = (app) => {
   // RESTful coin routes
   app.get('/api/coins', getCoinData);

};

// Get latest coin data, get all created alarms,
// determine if any alarms have thresholds that have been crossed,
// return coin data in JSON format
function getCoinData(req, res, done) {

   coinDataRepo.getCoinData((err, coinsData) => {

       alarmRepo.getAlarms((err, alarms) => {

           alarms.forEach((alarm) => {

               let latestCoinData = _.findWhere(coinsData, {id: alarm.coinId});

               if (latestCoinData && alarm.isTriggered(latestCoinData)) {

                   let message = `* ALARM * ${alarm.coinId}: $${latestCoinData.price_usd} is ${ alarm.thresholdDirection} threshold $${alarm.priceUsdThreshold}`;

                   smsService.sendSms(message, () => {
                       console.log(message);
                   });

               }

           });

           res.json(coinsData);
       });

   });

}

git checkout step-6-task-scheduling; npm install

npm install --save agenda

TWILIO_ACCOUNT_SID=yourAccountSid
TWILIO_AUTH_TOKEN=yourAuthToken
FROM_PHONE_NUMBER=yourTwilioPhoneNumber
TO_PHONE_NUMBER=yourPersonalSmsEnabledPhoneNumber
MONGODB_CONNECTION_STRING=mongodb://localhost:27017
MONGODB_DATABASE=coin-sms-alert

const mongoClient = require('mongodb').MongoClient;
const dotenv = require('dotenv');

let config = dotenv.config().parsed;
let dbConnectionString = config.MONGODB_CONNECTION_STRING;
let dbName = config.MONGODB_DATABASE;

let db = null;
let connectedClient = null;

// Connect to our MongoDB database and make database client available for use
exports.initialize = (done) => {
   if (db) return process.nextTick(done);

   console.log('Connecting to mongo database: ' + dbConnectionString);

   mongoClient.connect(dbConnectionString, (err, client) => {
       if (err) {
           console.log('Couldn\'t connect to mongo database', err);
           return done(err);
       }

       db = client.db(dbName);
       connectedClient = client;
       return done();
   });
};

// Close our MongoDB connection for shutdown
exports.dispose = (done) => {
   if (db) {
       console.log('Closing connection to mongo database: ' + dbConnectionString);
       db = null;

       connectedClient.close((err, result) => {
           if (err) {
               console.log('Error closing connection to mongo database', err);
               return done(err);
           }
           console.log('Database connection closed');
           return done();
       });
   } else {
       return process.nextTick(done);
   }
};

exports.getDb = () => {
   return db;
};

exports.alarms = () => {
   return db.collection('alarms');
};

exports.agendaJobs = () => {
   return db.collection('agendaJobs');
};

const Agenda = require('agenda');

const db = require('../dataAccess/mongoClientWrapper');
const checkAlarmJob = require('./checkAlarmJob');

const mongoConnectionString = `${process.env.MONGODB_CONNECTION_STRING}/${process.env.MONGODB_DATABASE}`;

let agenda = null;


exports.start = () => {
   // configure Agenda
   agenda = new Agenda({
       db: {
           address: mongoConnectionString
       },
       processEvery: 'one minute'
   });

   // Register event listener for when agenda starts up
   agenda.on('ready', () => {
       // Delete the jobs collection on startup
       deleteJobsCollection(() => {

           // Set up our job with agenda
           checkAlarmJob.register(agenda);
           // Job will run every minute
           checkAlarmJob.setSchedule('one minute');

           // Start agenda
           agenda.start(() => {
               console.log('Started jobs');
           });

       });
   });

   // error event listener
   agenda.on('error', (err) => {
       console.log('Error with Agenda!', err);
   });
};

// Gracefully stop errors
exports.stop = (done) => {
   agenda.stop(() => {
       console.log('Successfully shut down jobs');
       done();
   });
};

// Delete the MongoDB jobs collection
function deleteJobsCollection(done) {
   db.agendaJobs().drop(done);
}

const _ = require('underscore');

const coinDataRepo = require('../dataAccess/repos/coinDataRepository');
const alarmRepo = require('../dataAccess/repos/alarmRepository');
const smsService = require('../services/smsService');

const jobName = 'Check Alarm Job';
let agendaInstance = null;

// Register our job with the agenda instance
exports.register = (agenda) => {
   agendaInstance = agenda;

   // Define what this job will do
   agendaInstance.define(jobName, () => {
       console.log(`'${jobName}' executed at ${new Date()}`);

       // Request coin data from the CoinMarketCap API
       coinDataRepo.getCoinData((err, coinsData) => {
           // Retrieve all alarms from our database
           alarmRepo.getAlarms((err, alarms) => {
               // Iterate through all alarms
               alarms.forEach((alarm) => {
                   let latestCoinData = _.findWhere(coinsData, {id: alarm.coinId});

                   // If the alarm's coin is found and the alarm is triggered...
                   if (latestCoinData && alarm.isTriggered(latestCoinData)) {
                       let message = `* ALARM * ${alarm.coinId}: $${latestCoinData.price_usd} is ${ alarm.thresholdDirection} threshold $${alarm.priceUsdThreshold}`;

                       // ...send a SMS message!
                       smsService.sendSms(message, () => {
                           console.log(message);
                       });
                   }
               });
           });
       });
   });
};

// Set schedule
exports.setSchedule = (timeInterval) => {
   agendaInstance.every(timeInterval, jobName);
};

const express = require('express');
const bodyParser = require('body-parser');

const routes = require('./routes/routes');
const mongoClientWrapper = require('./dataAccess/mongoClientWrapper');
const jobs = require('./jobs/jobs');
const app = express();

// Use body-parser as middleware so that we have JSON data available on Request objects
app.use(bodyParser.json({type: 'application/json'}));

// Start listening on port 3000 to start receiving requests
app.listen(3000, () => {
   console.log('Coin Alert app listening on port 3000!');

   // Initialize our MongoDB client
   mongoClientWrapper.initialize(() => {
       // Set up routes
       routes.configure(app);
       jobs.start();
   });

   // Process terminal signal event listeners
   process.on('SIGINT', shutDown);
   process.on('SIGTERM',shutDown);
});

// Gracefully shut down
function shutDown() {
   console.log('\nShutting down!');
   // Stop all running jobs
   jobs.stop(() => {
       // safely clean up mongodb connection
       mongoClientWrapper.dispose(() => {
           process.exit(0);
       });

   });

}