NodeJS, интеграция API Календаря Google не аутентифицирована и возвращает неопределенное значение, независимо от наличия учетных данных и токена

Question

Прошу прощения за этот вопрос заранее. Я знаю, что это немного повсюду, но я просто потерян до такой степени, что я больше не уверен в том, что я спрашиваю. Не стесняйтесь задавать любые вопросы, если вам нужны разъяснения!

В настоящее время я работаю с вашим API Календаря Google. Мне нужна помощь, с моей интеграцией NodeJS. Мне нужно вытащить некоторые данные, касающиеся календаря, содержащего информацию о датах отпусков.

Кажется, я получаю сообщение об ошибке: "The API returned an error: Error: Daily Limit for Unauthenticated Use Exceeded. Continued use requires signup." Я попытался найти четкий ответ на эту проблему и способы ее решения. Но ни руководства StackOverflow, ни руководства Googles не помогают мне понять, что мне нужно делать, и какова / где на самом деле связь между моим приложением и API календаря Google.

Я также попытался провести рефакторинг кода примера из руководства по быстрому старту NodeJS на ваших страницах, чтобы я мог вернуть массив, содержащий объекты календаря с именем и описанием даты. Это дает неопределенный. Поэтому мне в основном нужна помощь в рассмотрении ошибок в моем коде и повторной оценке процедуры аутентификации, поскольку у меня настроены секретные учетные данные и токен из вашего API сохранен на моей машине.

Итак, у меня есть код, который при вызове контроллера календаря для получения данных я получаю undefined назад и ошибку

Код быстрого запуска: https://developers.google.com/calendar/quickstart/nodejs

Мой класс контроллера календаря:

const fs = require('fs');
const readline = require('readline');
const {google} = require('googleapis');

const SCOPES = ['https://www.googleapis.com/auth/calendar.readonly'];
const TOKEN_PATH = __dirname + '/token.json';

class CalendarController {

/**
 * Create an OAuth2 client with the given credentials.
 * @param {Object} credentials The authorization client credentials.
 */
  getOAuth2Client(credentials) {
    const {client_secret, client_id, redirect_uris} = credentials.installed;
    const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);

    fs.readFile(TOKEN_PATH, (err, token) => {
      if (err) return this.getNewAccessToken(oAuth2Client);
      oAuth2Client.setCredentials(JSON.parse(token));
      return oAuth2Client;
    });
  }
  /**
   * Get and store new token after prompting for user authorization.
   * @param {google.auth.OAuth2} oAuth2Client The OAuth2 client to get token for.
   */
  getNewAccessToken(oAuth2Client) {
    const authUrl = oAuth2Client.generateAuthUrl({
      access_type: 'offline',
      scope: SCOPES
    });
    console.log('Authorize this app by visiting this url: ', authUrl);
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });
    rl.question('Enter the code from the webpage here: ', (code) => {
      rl.close();
      oAuth2Client.getToken(code, (err, token) => {
        if (err) return console.error('Error retrieving access token', err);
        oAuth2Client.setCredentials(token);

        // Store the token to disk for later program executions
        fs.writeFile(TOKEN_PATH, JSON.stringify(token), (err) => {
          if (err) console.error(err);
          console.log('Token stored to: ', TOKEN_PATH);
        });
      });
      return oAuth2Client;
    });
  }

  /**
  * Lists the next maxResults events on the user's primary calendar.
  * @param {google.auth.OAuth2} auth An authorized OAuth2 client.
  */
  listEvents(auth) {
    const calendar = google.calendar({version: 'v3', auth});
    let vacation_events = [];
    calendar.events.list({
      calendarId: 'CALENDAR.ID.IS.OMITTED.CUZ.DUH',
      timeMin: (new Date()).toISOString(),
      maxResults: 250,
      singleEvents: true,
      orderBy: 'startTime',
    }, (err, res) => {
      if (err) return console.log('The API returned an error: ' + err);
      const events = res.data.items;
      if (events.length) {
        events.map((event, i) => {
          const start = event.start.dateTime || event.start.date;
          const end = event.end.dateTime || event.end.date;
          let vacation = {
              event_title: event.summary,
              event_description: event.description,
              dt_start: start,
              dt_end: end,
            }
          vacation_events.push(vacation);
        });
        console.log(vacation_events);
        return vacation_events;
      } else {
        console.log('No upcoming events found.');
      }
    });
  }

  getData() {
      fs.readFile(__dirname + '/credentials.json', (err, content) => {
        if (err) return console.error('Error loading client secrect file: ', err);

        console.log(
          this.listEvents(this.getOAuth2Client(JSON.parse(content)))
        );
        // return this.listEvents(this.getOAuth2Client(JSON.parse(content)));
      })
    }
  }

module.exports = CalendarController;

Чтобы было ясно. У меня есть файлы credentials.json и token.json в моем проекте, и они были сохранены на моем компьютере.

Answer 1

Так что в итоге я обратился за помощью к другу. Это приводит к следующему решению.

Одна из моих проблем заключалась в том, что когда вы используете быстрый запуск Googles для NodeJS для подключения к Calendar API, этот код попросит вас вручную обновить свои токены через браузер. Поэтому нам пришлось бороться с этой проблемой. Вторая проблема, с которой я столкнулся, заключалась в том, что мой код выполнялся не в правильном порядке. Как и многие другие вещи в JS, это была проблема асинхронного ожидания.

В следующем файле показана логика кода для «правильной» аутентификации на основе API Календаря Google, если вы хотите автоматизировать это, используя одного пользователя.

const http = require('http')
const fs = require('fs')
const moment = require('moment')
const jwt = require('jsonwebtoken')
const { google } = require('googleapis')

const { GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_REDIRECT_URIS } = process.env
const scope = ['https://www.googleapis.com/auth/calendar',
               'https://www.googleapis.com/auth/plus.login',
               'https://www.googleapis.com/auth/plus.me',
               'https://www.googleapis.com/auth/userinfo.email',
               'https://www.googleapis.com/auth/userinfo.profile']

// adminID omitted
const adminID = '123456789101112131415'

const auth = new google.auth.OAuth2(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_REDIRECT_URIS)
google.options({ auth })

const calendar = google.calendar({version: 'v3'})

const publicMethods = {
  async listAllUpcomingEvents() {
    const { data } = await calendar.events.list({
      // correct calendarId omitted
      calendarId: 'primary',
      timeMin: (new Date()).toISOString(),
      maxResults: 10,
      singleEvents: true,
      orderBy: 'startTime'
    })
    return data
  }
  /* Make all your calendar methods like shown here */
}

auth.on('tokens', (tokens) => {
  if(verifyTokenId(tokens)) {
    saveTokens(tokens)
  }
})

function saveTokens (tokens) {
  auth.setCredentials(tokens)
  nDebug('auth:token', tokens)
  tokenStore.tokens = tokens
}

/**
 * Generate a url for authentication
 *
 * @returns {string} Authentication url
 */
function getUrl () {
  return auth.generateAuthUrl({
    access_type: 'offline',
    prompt: 'consent',
    scope
  })
}

/**
 * Store token upon oauth callback
 *
 * @param {string} code Access code from auth callback
 * @returns {Object} tokens
 */
async function tokenCallback(code) {
  const { tokens } = await auth.getToken(code)
  return tokens
}

/**
 * Acquires profile information and verifies ID against adminID
 *
 * @param {Object} tokens
 * @returns {Boolean}
 */
async function verifyTokenId (tokens) {
  const info = jwt.decode(tokens.id_token)
  //const info = await auth.getTokenInfo(tokens.access_token)
  return info.sub === adminID
}

function getRouter () {
  const router = require('express').Router()

  router.get('/redirect', (req, res) => {
    res.redirect(getUrl())
  })

  router.get('/kappa', async (req, res) => {
    const data = await publicMethods.listAllUpcomingEvents() /* Use calendar functions like this */
    res.send(data)
  })

  router.get('/', async (req, res) => {
    try {
      const tokens = await tokenCallback(req.query.code)
      nDebug('tokens', tokens)
      if (!verifyTokenId(tokens)) {
        return res.status(403).send(http.STATUS_CODES['403'])
      }

      return res.send(info)

    } catch (e) {
      nDebug('error', e.data || e)
      res.status(500).send(e.data || e)
    }
  })

  return router
}

/** 
 * Debugging class
 * 
 * @param {string} string describing who calls the function
 * @param {function} callback function
 */
function nDebug (who, what) {
  console.log(moment().format(), who)
  console.dir(what, {color: true, depth: 3})
  console.log('#/', who)
}

/**
 * Singleton class to store and retrieve tokens
 *
 * @class TokenStore
 */
class TokenStore {
  /**
   * Creates an instance of TokenStore.
   * @param {Object} tokens - Collection of tokens to store
   * @param {string} tokens.access_token - Access token
   * @param {string} tokens.refresh_token - Refresh token
   * @memberof TokenStore
   */
  constructor (tokens) {
    this._tokens = tokens
  }

  /**
   * Returns stored tokens
   *
   * @memberof TokenStore
   */
  get tokens () {
    return this._tokens
  }

  /**
   *  Set tokens on TokenStore and writes them to file
   *
   * @memberof TokenStore
   */
  set tokens (tokens) {
    this._tokens = tokens
    TokenStore.saveToFile(tokens)
  }

  /**
   * Tries to load tokens from file, creates a blank TokenStore if none was found
   *
   * @static
   * @returns {TokenStore} New instance of TokenStore
   * @memberof TokenStore
   */
  static tryLoadOrMakeNew () {
    try {
      const data = this.loadFromFile()
      nDebug('token loaded', data)
      setImmediate(() => saveTokens(data))
      return new this(data)
    } catch (err) {
      if(err.code === 'ENOENT') {
        nDebug('no token loaded', {})
        return new this()
      } else {
        throw err /* Bollocks, something more serious is wrong, better throw up */
      }
    }
  }

  static loadFromFile () {
    return JSON.parse(fs.readFileSync(this.filePath(), this.opts()))
  }

  static saveToFile (tokens) {
    return fs.writeFileSync(this.filePath(), JSON.stringify(tokens, null, 2), this.opts())
  }

  static opts () {
    return { encoding: 'utf-8' }
  }

  static filePath () {
    return 'tokens.json'
  }
}

/* I feel ashamed */
const tokenStore = TokenStore.tryLoadOrMakeNew()

module.exports = Object.assign(google, publicMethods, { getRouter })

В конце концов, когда мы получаем ответ от Google и получаем токены обновления и access_token, мы сохраняем его локально в файле "token.json".

Остерегайтесь, если вы используете nodemon для запуска приложения, вы должны изменить npm start в package.json на "start": "nodemon --ignore 'tokens.json' app.js"

Я обновлю ответ, если в комментариях возникнут вопросы или исправления.