-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.js
184 lines (155 loc) · 5.27 KB
/
index.js
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
const express = require("express");
const path = require("path");
const bodyParser = require("body-parser");
const morgan = require("morgan");
const passport = require("passport");
const session = require("express-session");
const SteamStrategy = require("passport-steam").Strategy;
const pgSession = require("connect-pg-simple")(session);
const keys = require("./config/keys");
const gamesRouter = require("./routes/games");
const playersRouter = require("./routes/players");
const questsRouter = require("./routes/quests");
const authRouter = require("./routes/auth");
const paymentRouter = require("./routes/payments");
const patreonRouter = require("./routes/patreon");
const cosmeticsRouter = require("./routes/cosmetics");
const steamRouter = require("./routes/steam");
const logsRouter = require("./routes/logs");
const pollsRouter = require("./routes/polls");
const tournamentsRouter = require("./routes/tournaments");
const { pool } = require("./db/index");
const players = require("./db/players");
const port = process.env.PORT || 3000;
const app = express();
// -----------------------------------------------------
// Steam OpenID stuff
// Passport session setup.
// To support persistent login sessions, Passport needs to be able to
// serialize users into and deserialize users out of the session. Typically,
// this will be as simple as storing the user ID when serializing, and finding
// the user by ID when deserializing. However, since this example does not
// have a database of user records, the complete Steam profile is serialized
// and deserialized.
passport.serializeUser(async function (user, next) {
// create the user if they don't yet exist
const steamid = user.id;
const username = user.displayName;
const playerExists = await players.doesPlayerExist(steamid);
if (!playerExists) {
await players.createNewPlayer(steamid, username);
}
const { is_admin, poggers } = await players.getBasicPlayer(steamid);
// Increment quest progress for logging into the website
players.addQuestProgressByStat(steamid, "website_visits", 1);
// add db info to the user
user = {
...user,
isAdmin: is_admin,
poggers,
};
next(null, user);
});
passport.deserializeUser(function (obj, next) {
next(null, obj);
});
// Use the SteamStrategy within Passport.
// Strategies in passport require a `validate` function, which accept
// credentials (in this case, an OpenID identifier and profile), and invoke a
// callback with a user object.
const baseUrl = process.env.IS_PRODUCTION
? "https://www.pathofguardians.com"
: "http://localhost:3000";
passport.use(
new SteamStrategy(
{
returnURL: `${baseUrl}/api/auth/steam/return`,
realm: baseUrl,
apiKey: keys.steamAPIKey,
},
function (identifier, profile, next) {
return next(null, profile);
}
)
);
let sess = {
store: new pgSession({
pool: pool,
}),
secret: keys.sessionKey,
name: "id",
resave: false,
saveUninitialized: true,
cookie: {
maxAge: 2592000000,
},
};
if (process.env.IS_PRODUCTION) {
app.set("trust proxy", 1);
sess.cookie.secure = true;
}
app.use(session(sess));
// Initialize Passport! Also use passport.session() middleware, to support
// persistent login sessions (recommended).
app.use(passport.initialize());
app.use(passport.session());
function skipLog(req, res) {
var url = req.url;
if (url.indexOf("?") > 0) url = url.substr(0, url.indexOf("?"));
if (url.match(/(js|jpg|png|ico|css|woff|woff2|eot|svg|otf)$/gi)) {
return true;
}
return false;
}
app.use(morgan("short", { skip: skipLog }));
app.use(
bodyParser.json({
// Because Stripe needs the raw body, we compute it but only when hitting the Stripe callback URL.
verify: function (req, res, buf) {
var url = req.originalUrl;
if (url.endsWith("/webhook")) {
req.rawBody = buf.toString();
}
},
})
);
app.use(
bodyParser.urlencoded({
extended: true,
})
);
app.use(express.static(path.join(__dirname, "client/dist")));
// app.use("/api/test", testRouter);
app.use("/api/games", gamesRouter);
app.use("/api/players", playersRouter);
app.use("/api/quests", questsRouter);
app.use("/api/auth", authRouter);
app.use("/api/payments", paymentRouter);
app.use("/api/patreon", patreonRouter);
app.use("/api/cosmetics", cosmeticsRouter);
app.use("/api/steam", steamRouter);
app.use("/api/logs", logsRouter);
app.use("/api/polls", pollsRouter);
app.use("/api/tournaments", tournamentsRouter);
app.get("*", (req, res) => {
res.sendFile(path.join(__dirname + "/client/dist/index.html"));
});
const server = app.listen(port, () => {
console.log(`App running on port ${port}.`);
});
process.on("SIGINT", () => {
console.info("SIGINT signal received.");
// Stops the server from accepting new connections and finishes existing connections.
server.close(function (err) {
// if error, log and exit with error (1 code)
if (err) {
console.error(err);
process.exit(1);
}
// close your database connection and exit with success (0 code)
pool.end(() => {
console.log("pool has ended");
process.exit(0);
});
});
});