ทดลองดึงข้อมูล Calendar ด้วย Google Calendar API บน Nodejs

npm init

npm install googleapis googlepauth-library --save

npm install hapi --save

'use strict'

const Hapi = require('hapi')
const server = new Hapi.Server()

server.connection({
  host: 'localhost',
  port: 2345
})

server.route({
  method: 'GET',
  path: '/',
  handler: (request, reply) => {
    reply({ message: 'Hello World' })
  }
})

server.start(() => {
  console.log(`Server is running at ${server.info.uri}`)
})

"scripts": {
  "start": "node server.js"
}

npm start

{
  "installed": {
    "client_id": "xxxxxxx.apps.googleusercontent.com",
    "project_id": "project_id_1234",
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://accounts.google.com/o/oauth2/token",
    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
    "client_secret": "client_secret123456",
    "redirect_uris": ["urn:ietf:wg:oauth:2.0:oob", "http://localhost"]
  }
}

var fs = require('fs')
var readline = require('readline')
var google = require('googleapis')
var googleAuth = require('google-auth-library')

// If modifying these scopes, delete your previously saved credentials
// at ~/.credentials/calendar-nodejs-quickstart.json
var SCOPES = ['https://www.googleapis.com/auth/calendar']
var TOKEN_DIR =
  (process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE) +
  '/.credentials/'
var TOKEN_PATH = TOKEN_DIR + 'calendar-nodejs-quickstart.json'

// Load client secrets from a local file.
fs.readFile('client_secret.json', function processClientSecrets(err, content) {
  if (err) {
    console.log('Error loading client secret file: ' + err)
    return
  }
  // Authorize a client with the loaded credentials, then call the
  // Google Calendar API.
  authorize(JSON.parse(content), listEvents)
})

/**
 * Create an OAuth2 client with the given credentials, and then execute the
 * given callback function.
 *
 * @param {Object} credentials The authorization client credentials.
 * @param {function} callback The callback to call with the authorized client.
 */
function authorize(credentials, callback) {
  var clientSecret = credentials.installed.client_secret
  var clientId = credentials.installed.client_id
  var redirectUrl = credentials.installed.redirect_uris[0]
  var auth = new googleAuth()
  var oauth2Client = new auth.OAuth2(clientId, clientSecret, redirectUrl)

  // Check if we have previously stored a token.
  fs.readFile(TOKEN_PATH, function (err, token) {
    if (err) {
      getNewToken(oauth2Client, callback)
    } else {
      oauth2Client.credentials = JSON.parse(token)
      callback(oauth2Client)
    }
  })
}

/**
 * Get and store new token after prompting for user authorization, and then
 * execute the given callback with the authorized OAuth2 client.
 *
 * @param {google.auth.OAuth2} oauth2Client The OAuth2 client to get token for.
 * @param {getEventsCallback} callback The callback to call with the authorized
 *     client.
 */
function getNewToken(oauth2Client, callback) {
  var authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: SCOPES
  })
  console.log('Authorize this app by visiting this url: ', authUrl)
  var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  })
  rl.question('Enter the code from that page here: ', function (code) {
    rl.close()
    oauth2Client.getToken(code, function (err, token) {
      if (err) {
        console.log('Error while trying to retrieve access token', err)
        return
      }
      oauth2Client.credentials = token
      storeToken(token)
      callback(oauth2Client)
    })
  })
}

/**
 * Store token to disk be used in later program executions.
 *
 * @param {Object} token The token to store to disk.
 */
function storeToken(token) {
  try {
    fs.mkdirSync(TOKEN_DIR)
  } catch (err) {
    if (err.code != 'EEXIST') {
      throw err
    }
  }
  fs.writeFile(TOKEN_PATH, JSON.stringify(token))
  console.log('Token stored to ' + TOKEN_PATH)
}

/**
 * Lists the next 10 events on the user's primary calendar.
 *
 * @param {google.auth.OAuth2} auth An authorized OAuth2 client.
 */
function listEvents(auth) {
  var calendar = google.calendar('v3')
  calendar.events.list(
    {
      auth: auth,
      calendarId: 'primary',
      timeMin: new Date().toISOString(),
      maxResults: 10,
      singleEvents: true,
      orderBy: 'startTime'
    },
    function (err, response) {
      if (err) {
        console.log('The API returned an error: ' + err)
        return
      }
      var events = response.items
      if (events.length == 0) {
        console.log('No upcoming events found.')
      } else {
        console.log('Upcoming 10 events:')
        for (var i = 0; i < events.length; i++) {
          var event = events[i]
          var start = event.start.dateTime || event.start.date
          console.log('%s - %s', start, event.summary)
        }
      }
    }
  )
}

var SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']

var SCOPES = ['https://www.googleapis.com/auth/calendar']

node quickstart.js

Authorize this app by visiting this url:  https://accounts.google.com/o/oauth2/auth?access_type=offline&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar.readonly&response_type=code&client_id=12234.apps.googleusercontent.com&redirect_uri=xxxxx
Enter the code from that page here:

'use strict'

const google = require('googleapis')
const googleAuth = require('google-auth-library')
const calendar = google.calendar('v3')

const fs = require('fs')

const SCOPES = [process.env.SCOPES]
const TOKEN_DIR =
  (process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE) +
  '/.credentials/'
const TOKEN_PATH = TOKEN_DIR + 'calendar-nodejs-quickstart.json'

module.exports = {
  authorize: callback => {
    fs.readFile('client_secret.json', function processClientSecrets(
      err,
      content
    ) {
      if (err) {
        console.log('Error loading client secret file: ' + err)
        return
      }

      let credentials = JSON.parse(content)
      var clientSecret = credentials.installed.client_secret
      var clientId = credentials.installed.client_id
      var redirectUrl = credentials.installed.redirect_uris[0]
      var auth = new googleAuth()
      var oauth2Client = new auth.OAuth2(clientId, clientSecret, redirectUrl)

      // Check if we have previously stored a token.
      fs.readFile(TOKEN_PATH, function (err, token) {
        if (err) {
          return callback(err)
        } else {
          oauth2Client.credentials = JSON.parse(token)
          return callback(null, oauth2Client)
        }
      })
    })
  },

  getNewToken: (oauth2Client, callback) => {
    var authUrl = oauth2Client.generateAuthUrl({
      access_type: 'offline',
      scope: SCOPES
    })
    console.log('Authorize this app by visiting this url: ', authUrl)
    var rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    })
    rl.question('Enter the code from that page here: ', function (code) {
      rl.close()
      oauth2Client.getToken(code, function (err, token) {
        if (err) {
          console.log('Error while trying to retrieve access token', err)
          return
        }
        oauth2Client.credentials = token
        storeToken(token)
        callback(oauth2Client)
      })
    })
  },

  listEvents: (auth, callback) => {
    calendar.events.list(
      {
        auth: auth,
        calendarId: process.env.CALENDAR_ID,
        timeMin: new Date().toISOString(),
        maxResults: 50,
        singleEvents: true,
        orderBy: 'startTime'
      },
      (err, response) => {
        if (err) {
          return callback(err)
        }
        return callback(null, response)
      }
    )
  },

  createEvent: (auth, event, callback) => {
    calendar.events.insert(
      {
        auth: auth,
        calendarId: process.env.CALENDAR_ID,
        resource: event
      },
      (err, event) => {
        if (err) {
          return callback(
            'There was an error contacting the Calendar service: ' + err
          )
        }
        return callback(null, event.htmlLink)
      }
    )
  }
}

const lib = require('./lib')

lib.authorize()
lib.listEvents()
lib.createEvent()

'use strict'

const controller = require('./controller')

module.exports = [
  {
    method: 'GET',
    path: '/',
    config: controller.index
  },
  {
    method: 'GET',
    path: '/events',
    config: controller.events
  },
  {
    method: 'POST',
    path: '/events',
    config: controller.create
  }
]

'use strict'

const validate = require('./validate')
const lib = require('./lib')

module.exports = {
  index: {
    handler: (request, reply) => {
      reply({
        message: 'Google Calendar API',
        endpoint: {
          listEvents: 'GET /events',
          createEvent: 'POST /events'
        }
      })
    }
  },

  create: {
    validate: validate.create,
    handler: (request, reply) => {
      let payload = request.payload

      let summary = payload.summary
      let description = payload.description
      let email = payload.email
      let startDate = payload.startDate
      let endDate = payload.endDate

      lib.authorize((err, auth) => {
        if (err) return reply(err)

        let options = lib.eventBuilder(payload)
        options.auth = auth

        lib.createEvent(options, (err, result) => {
          if (err) return reply(err)

          return reply(result)
        })
      })
    }
  },

  events: {
    handler: (request, reply) => {
      lib.authorize((err, auth) => {
        if (err) return reply(err)

        lib.listEvents(auth, (err, response) => {
          if (err) return reply(err)

          return reply(response)
        })
      })
    }
  }
}

'use strict'

const Joi = require('joi')

module.exports = {
  create: {
    payload: {
      email: Joi.string().email().required(),
      title: Joi.string().required(),
      description: Joi.string().required(),
      startDate: Joi.string().required(),
      endDate: Joi.string().required()
    }
  }
}

'use strict'

const Hapi = require('hapi')
const server = new Hapi.Server()
const routes = require('./routes')

server.connection({
  host: 'localhost',
  port: 2345
})

server.route(routes)

server.start(() => {
  console.log(`Server is running at ${server.info.uri}`)
})

node server.js