summaryrefslogtreecommitdiff
path: root/src/sinks/GoogleCalendarSink.ts
blob: 374cc489a8291589590e1cdd66b0d7ae9aa24399 (plain)
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
import * as fs from 'fs';
import * as readline from 'readline';

import {google} from 'googleapis';

import {ISink} from './ISink';
import {IEvent} from '../core/IEvent';


const OAuth2Client = google.auth.OAuth2;
const scopes = ['https://www.googleapis.com/auth/calendar'];

const credentialsPath = 'etc/google/client_secret.json';
const tokenPath = 'etc/google/credentials.json';

const clientPromise = new Promise((resolve, reject) => {
    fs.readFile(credentialsPath, (err, data) => {
        if (err) return reject(err);

        const credentials = JSON.parse(data.toString());
        const {client_secret, client_id, redirect_uris} = credentials.installed;

        const client = new OAuth2Client(client_id, client_secret, redirect_uris[0]);

        fs.readFile(tokenPath, (err, data) => {
            if (err) {
                const authUrl = client.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 that page here: ', code => {
                    rl.close();
                    client.getToken(code, (err, token) => {
                        if (err) return reject(err);
                        fs.writeFile(tokenPath, JSON.stringify(token), err => err ? console.error(err) : 0);
                        client.setCredentials(token);
                        resolve(client);
                    });
                });
            }
            else {
                client.setCredentials(JSON.parse(data.toString()));
                resolve(client);
            }
        });
    });
});


const calendarPromise = clientPromise.then(auth => google.calendar({version: 'v3', auth}));


export class GoogleCalendarSink implements ISink {
    private _calendarId: string;

    constructor(calendarId = 'primary') {
        this._calendarId = calendarId;
    }

    createEvent(event: IEvent): Promise<void> {
        const googleEvent = {
            summary: event.summary,
            description: event.description,
            location: event.location,
            start: {
                dateTime: event.start.toISOString()
            },
            end: {
                dateTime: event.end.toISOString()
            },
            reminders: {
                useDefault: false
            }
        };

        return calendarPromise.then(calendar => {
            return new Promise<void>((resolve, reject) => {
                calendar.events.insert({
                    calendarId: this._calendarId,
                    resource: googleEvent,
                }, function (err, event) {
                    if (err) return reject(err);
                    resolve();
                });
            });
        });
    }

    commit(): Promise<void> {
        return Promise.resolve();
    }
}