aboutsummaryrefslogtreecommitdiff
path: root/src/server/ApiManagers/GeneralGoogleManager.ts
blob: 171912185a9bab4b28d1d973f12c0028d30862db (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
import ApiManager, { Registration } from "./ApiManager";
import { Method, _permission_denied } from "../RouteManager";
import { GoogleApiServerUtils } from "../apis/google/GoogleApiServerUtils";
import { Database } from "../database";
import RouteSubscriber from "../RouteSubscriber";

const deletionPermissionError = "Cannot perform specialized delete outside of the development environment!";

const EndpointHandlerMap = new Map<GoogleApiServerUtils.Action, GoogleApiServerUtils.ApiRouter>([
    ["create", (api, params) => api.create(params)],
    ["retrieve", (api, params) => api.get(params)],
    ["update", (api, params) => api.batchUpdate(params)],
]);

export default class GeneralGoogleManager extends ApiManager {

    protected initialize(register: Registration): void {

        register({
            method: Method.GET,
            subscription: "/readGoogleAccessToken",
            onValidation: async ({ user, res }) => {
                const userId = user.id;
                const token = await GoogleApiServerUtils.retrieveAccessToken(userId);
                if (!token) {
                    return res.send(GoogleApiServerUtils.generateAuthenticationUrl());
                }
                return res.send(token);
            }
        });

        register({
            method: Method.POST,
            subscription: "/writeGoogleAccessToken",
            onValidation: async ({ user, req, res }) => {
                res.send(await GoogleApiServerUtils.processNewUser(user.id, req.body.authenticationCode));
            }
        });

        register({
            method: Method.GET,
            subscription: "/deleteWithGoogleCredentials",
            onValidation: async ({ res, isRelease }) => {
                if (isRelease) {
                    return _permission_denied(res, deletionPermissionError);
                }
                await Database.Auxiliary.GoogleAuthenticationToken.DeleteAll();
                res.redirect("/delete");
            }
        });

        register({
            method: Method.POST,
            subscription: new RouteSubscriber("/googleDocs").add("sector", "action"),
            onValidation: async ({ req, res, user }) => {
                let sector: GoogleApiServerUtils.Service = req.params.sector as GoogleApiServerUtils.Service;
                let action: GoogleApiServerUtils.Action = req.params.action as GoogleApiServerUtils.Action;
                const endpoint = await GoogleApiServerUtils.GetEndpoint(GoogleApiServerUtils.Service[sector], user.id);
                let handler = EndpointHandlerMap.get(action);
                if (endpoint && handler) {
                    handler(endpoint, req.body)
                        .then(response => res.send(response.data))
                        .catch(exception => res.send(exception));
                    return;
                }
                res.send(undefined);
            }
        });

    }
}