1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
import { google, docs_v1 } from "googleapis";
import { createInterface } from "readline";
import { readFile, writeFile } from "fs";
import { OAuth2Client } from "google-auth-library";
/**
* Server side authentication for Google Api queries.
*/
export namespace GoogleApiServerUtils {
// If modifying these scopes, delete token.json.
const prefix = 'https://www.googleapis.com/auth/';
const SCOPES = [
'documents.readonly',
'documents',
'drive',
'drive.file',
];
// The file token.json stores the user's access and refresh tokens, and is
// created automatically when the authorization flow completes for the first
// time.
export const parseBuffer = (data: Buffer) => JSON.parse(data.toString());
export namespace Docs {
export interface CredentialPaths {
credentials: string;
token: string;
}
export type Endpoint = docs_v1.Docs;
export const GetEndpoint = async (paths: CredentialPaths) => {
return new Promise<Endpoint>((resolve, reject) => {
readFile(paths.credentials, (err, credentials) => {
if (err) {
reject(err);
return console.log('Error loading client secret file:', err);
}
return authorize(parseBuffer(credentials), paths.token).then(auth => {
resolve(google.docs({ version: "v1", auth }));
});
});
});
};
}
/**
* Create an OAuth2 client with the given credentials, and returns the promise resolving to the authenticated client
* @param {Object} credentials The authorization client credentials.
*/
export function authorize(credentials: any, token_path: string): Promise<OAuth2Client> {
const { client_secret, client_id, redirect_uris } = credentials.installed;
const oAuth2Client = new google.auth.OAuth2(
client_id, client_secret, redirect_uris[0]);
return new Promise<OAuth2Client>((resolve, reject) => {
readFile(token_path, (err, token) => {
// Check if we have previously stored a token.
if (err) {
return getNewToken(oAuth2Client, token_path).then(resolve, reject);
}
oAuth2Client.setCredentials(parseBuffer(token));
resolve(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 for the authorized client.
*/
function getNewToken(oAuth2Client: OAuth2Client, token_path: string) {
return new Promise<OAuth2Client>((resolve, reject) => {
const authUrl = oAuth2Client.generateAuthUrl({
access_type: 'offline',
scope: SCOPES.map(relative => prefix + relative),
});
console.log('Authorize this app by visiting this url:', authUrl);
const rl = createInterface({
input: process.stdin,
output: process.stdout,
});
rl.question('Enter the code from that page here: ', (code) => {
rl.close();
oAuth2Client.getToken(code, (err, token) => {
if (err || !token) {
reject(err);
return console.error('Error retrieving access token', err);
}
oAuth2Client.setCredentials(token);
// Store the token to disk for later program executions
writeFile(token_path, JSON.stringify(token), (err) => {
if (err) {
console.error(err);
reject(err);
}
console.log('Token stored to', token_path);
});
resolve(oAuth2Client);
});
});
});
}
}
|
