6781993403

Committed 07 Nov 2023 08:42AM UTC coverage: 85.089% (-0.04%) from 85.128%

Build # 6781993403

Build Type

Pull #53

github

Committed by

web-flow

Commit Message

Merge 8e8409ac9 into 0ba267498

Pull Request Pull Request #53: Added python microservice

Run Details

10246 of 13276 branches covered (0.0%)

Branch coverage included in aggregate %.

265 of 327 new or added lines in 6 files covered. (81.04%)

5 existing lines in 2 files now uncovered.

22714 of 25460 relevant lines covered (89.21%)

3085.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.53

/src/controllers/index.js

/* eslint-disable no-useless-concat */
/* eslint-disable function-paren-newline */
/* eslint-disable arrow-parens */
/* eslint-disable implicit-arrow-linebreak */
/* eslint-disable operator-linebreak */
/* eslint-disable quotes */

"use strict";

const nconf = require("nconf");
const validator = require("validator");

const meta = require("../meta");
const user = require("../user");
const plugins = require("../plugins");
const privileges = require("../privileges");
const helpers = require("./helpers");

const Controllers = module.exports;

Controllers.ping = require("./ping");
Controllers.home = require("./home");
Controllers.topics = require("./topics");
Controllers.posts = require("./posts");
Controllers.career = require("./career");
Controllers.categories = require("./categories");
Controllers.category = require("./category");
Controllers.unread = require("./unread");
Controllers.recent = require("./recent");
Controllers.popular = require("./popular");
Controllers.top = require("./top");
Controllers.tags = require("./tags");
Controllers.search = require("./search");
Controllers.user = require("./user");
Controllers.users = require("./users");
Controllers.groups = require("./groups");
Controllers.accounts = require("./accounts");
Controllers.authentication = require("./authentication");
Controllers.api = require("./api");
Controllers.admin = require("./admin");
Controllers.globalMods = require("./globalmods");
Controllers.mods = require("./mods");
Controllers.sitemap = require("./sitemap");
Controllers.osd = require("./osd");
Controllers["404"] = require("./404");
Controllers.errors = require("./errors");
Controllers.composer = require("./composer");

Controllers.write = require("./write");

Controllers.reset = async function (req, res) {
    if (meta.config["password:disableEdit"]) {
        return helpers.notAllowed(req, res);
    }

    res.locals.metaTags = {
        ...res.locals.metaTags,
        name: "robots",
        content: "noindex",
    };

    const renderReset = function (code, valid) {
        res.render("reset_code", {
            valid: valid,
            displayExpiryNotice: req.session.passwordExpired,
            code: code,
            minimumPasswordLength: meta.config.minimumPasswordLength,
            minimumPasswordStrength: meta.config.minimumPasswordStrength,
            breadcrumbs: helpers.buildBreadcrumbs([
                {
                    text: "[[reset_password:reset_password]]",
                    url: "/reset",
                },
                {
                    text: "[[reset_password:update_password]]",
                },
            ]),
            title: "[[pages:reset]]",
        });
        delete req.session.passwordExpired;
    };

    if (req.params.code) {
        req.session.reset_code = req.params.code;
    }

    if (req.session.reset_code) {
        // Validate and save to local variable before removing from session
        const valid = await user.reset.validate(req.session.reset_code);
        renderReset(req.session.reset_code, valid);
        delete req.session.reset_code;
    } else {
        res.render("reset", {
            code: null,
            breadcrumbs: helpers.buildBreadcrumbs([
                {
                    text: "[[reset_password:reset_password]]",
                },
            ]),
            title: "[[pages:reset]]",
        });
    }
};

Controllers.login = async function (req, res) {
    const data = { loginFormEntry: [] };
    const loginStrategies =
        require("../routes/authentication").getLoginStrategies();
    const registrationType = meta.config.registrationType || "normal";
    const allowLoginWith = meta.config.allowLoginWith || "username-email";

    let errorText;
    if (req.query.error === "csrf-invalid") {
        errorText = "[[error:csrf-invalid]]";
    } else if (req.query.error) {
        errorText = validator.escape(String(req.query.error));
    }

    if (req.headers["x-return-to"]) {
        req.session.returnTo = req.headers["x-return-to"];
    }

    // Occasionally, x-return-to is passed a full url.
    req.session.returnTo =
        req.session.returnTo &&
        req.session.returnTo
            .replace(nconf.get("base_url"), "")
            .replace(nconf.get("relative_path"), "");

    data.alternate_logins = loginStrategies.length > 0;
    data.authentication = loginStrategies;
    data.allowRegistration = registrationType === "normal";
    data.allowLoginWith = `[[login:${allowLoginWith}]]`;
    data.breadcrumbs = helpers.buildBreadcrumbs([
        {
            text: "[[global:login]]",
        },
    ]);
    data.error = req.flash("error")[0] || errorText;
    data.title = "[[pages:login]]";
    data.allowPasswordReset = !meta.config["password:disableEdit"];

    const hasLoginPrivilege = await privileges.global.canGroup(
        "local:login",
        "registered-users"
    );
    data.allowLocalLogin =
        hasLoginPrivilege || parseInt(req.query.local, 10) === 1;

    if (
        !data.allowLocalLogin &&
        !data.allowRegistration &&
        data.alternate_logins &&
        data.authentication.length === 1
    ) {
        return helpers.redirect(res, { external: data.authentication[0].url });
    }

    // Re-auth challenge, pre-fill username
    if (req.loggedIn) {
        const userData = await user.getUserFields(req.uid, ["username"]);
        data.username = userData.username;
        data.alternate_logins = false;
    }
    res.render("login", data);
};

Controllers.register = async function (req, res, next) {
    const registrationType = meta.config.registrationType || "normal";

    if (registrationType === "disabled") {
        return setImmediate(next);
    }

    let errorText;
    const returnTo = (req.headers["x-return-to"] || "").replace(
        nconf.get("base_url") + nconf.get("relative_path"),
        ""
    );
    if (req.query.error === "csrf-invalid") {
        errorText = "[[error:csrf-invalid]]";
    }
    try {
        if (
            registrationType === "invite-only" ||
            registrationType === "admin-invite-only"
        ) {
            try {
                await user.verifyInvitation(req.query);
            } catch (e) {
                return res.render("400", {
                    error: e.message,
                });
            }
        }

        if (returnTo) {
            req.session.returnTo = returnTo;
        }

        const loginStrategies =
            require("../routes/authentication").getLoginStrategies();
        res.render("register", {
            "register_window:spansize": loginStrategies.length
                ? "col-md-6"
                : "col-md-12",
            alternate_logins: !!loginStrategies.length,
            authentication: loginStrategies,

            minimumUsernameLength: meta.config.minimumUsernameLength,
            maximumUsernameLength: meta.config.maximumUsernameLength,
            minimumPasswordLength: meta.config.minimumPasswordLength,
            minimumPasswordStrength: meta.config.minimumPasswordStrength,
            breadcrumbs: helpers.buildBreadcrumbs([
                {
                    text: "[[register:register]]",
                },
            ]),
            regFormEntry: [
                {
                    label: "Account Type",
                    styleName: "account-type",
                    html: `
                        <select class="form-control" name="account-type" aria-label="Account Type">
                            <option value="student" selected>Student</option>
                            <option value="instructor">Instructor</option>
                            <option value="recruiter">Recruiter</option>
                        </select>
                    `,
                },
            ],
            error: req.flash("error")[0] || errorText,
            title: "[[pages:register]]",
        });
    } catch (err) {
        next(err);
    }
};

Controllers.registerInterstitial = async function (req, res, next) {
    if (!req.session.hasOwnProperty("registration")) {
        return res.redirect(`${nconf.get("relative_path")}/register`);
    }
    try {
        const data = await plugins.hooks.fire("filter:register.interstitial", {
            req,
            userData: req.session.registration,
            interstitials: [],
        });

        if (!data.interstitials.length) {
            // No interstitials, redirect to home
            const returnTo =
                req.session.returnTo || req.session.registration.returnTo;
            delete req.session.registration;
            return helpers.redirect(res, returnTo || "/");
        }

        const errors = req.flash("errors");
        const renders = data.interstitials.map((interstitial) =>
            req.app.renderAsync(interstitial.template, {
                ...(interstitial.data || {}),
                errors,
            })
        );
        const sections = await Promise.all(renders);

        res.render("registerComplete", {
            title: "[[pages:registration-complete]]",
            register: data.userData.register,
            sections,
            errors,
        });
    } catch (err) {
        next(err);
    }
};

Controllers.confirmEmail = async (req, res, next) => {
    try {
        await user.email.confirmByCode(req.params.code, req.session.id);
    } catch (e) {
        if (e.message === "[[error:invalid-data]]") {
            return next();
        }

        throw e;
    }

    res.render("confirm", {
        title: "[[pages:confirm]]",
    });
};

Controllers.robots = function (req, res) {
    res.set("Content-Type", "text/plain");

    if (meta.config["robots:txt"]) {
        res.send(meta.config["robots:txt"]);
    } else {
        res.send(
            `${"User-agent: *\n" + "Disallow: "}${nconf.get(
                "relative_path"
            )}/admin/\n` +
                `Disallow: ${nconf.get("relative_path")}/reset/\n` +
                `Disallow: ${nconf.get("relative_path")}/compose\n` +
                `Sitemap: ${nconf.get("url")}/sitemap.xml`
        );
    }
};

Controllers.manifest = async function (req, res) {
    const manifest = {
        name: meta.config.title || "NodeBB",
        short_name: meta.config["title:short"] || meta.config.title || "NodeBB",
        start_url: nconf.get("url"),
        display: "standalone",
        orientation: "portrait",
        theme_color: meta.config.themeColor || "#ffffff",
        background_color: meta.config.backgroundColor || "#ffffff",
        icons: [],
    };

    if (meta.config["brand:touchIcon"]) {
        manifest.icons.push(
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-36.png`,
                sizes: "36x36",
                type: "image/png",
                density: 0.75,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-48.png`,
                sizes: "48x48",
                type: "image/png",
                density: 1.0,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-72.png`,
                sizes: "72x72",
                type: "image/png",
                density: 1.5,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-96.png`,
                sizes: "96x96",
                type: "image/png",
                density: 2.0,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-144.png`,
                sizes: "144x144",
                type: "image/png",
                density: 3.0,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-192.png`,
                sizes: "192x192",
                type: "image/png",
                density: 4.0,
            },
            {
                src: `${nconf.get(
                    "relative_path"
                )}/assets/uploads/system/touchicon-512.png`,
                sizes: "512x512",
                type: "image/png",
                density: 10.0,
            }
        );
    }

    if (meta.config["brand:maskableIcon"]) {
        manifest.icons.push({
            src: `${nconf.get(
                "relative_path"
            )}/assets/uploads/system/maskableicon-orig.png`,
            type: "image/png",
            purpose: "maskable",
        });
    } else if (meta.config["brand:touchIcon"]) {
        manifest.icons.push({
            src: `${nconf.get(
                "relative_path"
            )}/assets/uploads/system/touchicon-orig.png`,
            type: "image/png",
            purpose: "maskable",
        });
    }

    const data = await plugins.hooks.fire("filter:manifest.build", {
        req: req,
        res: res,
        manifest: manifest,
    });
    res.status(200).json(data.manifest);
};

Controllers.outgoing = function (req, res, next) {
    const url = req.query.url || "";
    const allowedProtocols = [
        "http",
        "https",
        "ftp",
        "ftps",
        "mailto",
        "news",
        "irc",
        "gopher",
        "nntp",
        "feed",
        "telnet",
        "mms",
        "rtsp",
        "svn",
        "tel",
        "fax",
        "xmpp",
        "webcal",
    ];
    const parsed = require("url").parse(url);

    if (
        !url ||
        !parsed.protocol ||
        !allowedProtocols.includes(parsed.protocol.slice(0, -1))
    ) {
        return next();
    }

    res.render("outgoing", {
        outgoing: validator.escape(String(url)),
        title: meta.config.title,
        breadcrumbs: helpers.buildBreadcrumbs([
            {
                text: "[[notifications:outgoing_link]]",
            },
        ]),
    });
};

Controllers.termsOfUse = async function (req, res, next) {
    if (!meta.config.termsOfUse) {
        return next();
    }
    const termsOfUse = await plugins.hooks.fire("filter:parse.post", {
        postData: {
            content: meta.config.termsOfUse || "",
        },
    });
    res.render("tos", {
        termsOfUse: termsOfUse.postData.content,
    });
};

1	/* eslint-disable no-useless-concat */
2	/* eslint-disable function-paren-newline */
3	/* eslint-disable arrow-parens */
4	/* eslint-disable implicit-arrow-linebreak */
5	/* eslint-disable operator-linebreak */
6	/* eslint-disable quotes */
7
8	"use strict";
9
10	const nconf = require("nconf");	4✔
11	const validator = require("validator");	4✔
12
13	const meta = require("../meta");	4✔
14	const user = require("../user");	4✔
15	const plugins = require("../plugins");	4✔
16	const privileges = require("../privileges");	4✔
17	const helpers = require("./helpers");	4✔
18
19	const Controllers = module.exports;	4✔
20
21	Controllers.ping = require("./ping");	4✔
22	Controllers.home = require("./home");	4✔
23	Controllers.topics = require("./topics");	4✔
24	Controllers.posts = require("./posts");	4✔
25	Controllers.career = require("./career");	4✔
26	Controllers.categories = require("./categories");	4✔
27	Controllers.category = require("./category");	4✔
28	Controllers.unread = require("./unread");	4✔
29	Controllers.recent = require("./recent");	4✔
30	Controllers.popular = require("./popular");	4✔
31	Controllers.top = require("./top");	4✔
32	Controllers.tags = require("./tags");	4✔
33	Controllers.search = require("./search");	4✔
34	Controllers.user = require("./user");	4✔
35	Controllers.users = require("./users");	4✔
36	Controllers.groups = require("./groups");	4✔
37	Controllers.accounts = require("./accounts");	4✔
38	Controllers.authentication = require("./authentication");	4✔
39	Controllers.api = require("./api");	4✔
40	Controllers.admin = require("./admin");	4✔
41	Controllers.globalMods = require("./globalmods");	4✔
42	Controllers.mods = require("./mods");	4✔
43	Controllers.sitemap = require("./sitemap");	4✔
44	Controllers.osd = require("./osd");	4✔
45	Controllers["404"] = require("./404");	4✔
46	Controllers.errors = require("./errors");	4✔
47	Controllers.composer = require("./composer");	4✔
48
49	Controllers.write = require("./write");	4✔
50
51	Controllers.reset = async function (req, res) {	4✔
52	if (meta.config["password:disableEdit"]) {	8!
53	return helpers.notAllowed(req, res);	×
54	}
55
56	res.locals.metaTags = {	8✔
57	...res.locals.metaTags,
58	name: "robots",
59	content: "noindex",
60	};
61
62	const renderReset = function (code, valid) {	8✔
63	res.render("reset_code", {	4✔
64	valid: valid,
65	displayExpiryNotice: req.session.passwordExpired,
66	code: code,
67	minimumPasswordLength: meta.config.minimumPasswordLength,
68	minimumPasswordStrength: meta.config.minimumPasswordStrength,
69	breadcrumbs: helpers.buildBreadcrumbs([
70	{
71	text: "[[reset_password:reset_password]]",
72	url: "/reset",
73	},
74	{
75	text: "[[reset_password:update_password]]",
76	},
77	]),
78	title: "[[pages:reset]]",
79	});
80	delete req.session.passwordExpired;	4✔
81	};
82
83	if (req.params.code) {	8✔
84	req.session.reset_code = req.params.code;	4✔
85	}
86
87	if (req.session.reset_code) {	8✔
88	// Validate and save to local variable before removing from session
89	const valid = await user.reset.validate(req.session.reset_code);	4✔
90	renderReset(req.session.reset_code, valid);	4✔
91	delete req.session.reset_code;	4✔
92	} else {
93	res.render("reset", {	4✔
94	code: null,
95	breadcrumbs: helpers.buildBreadcrumbs([
96	{
97	text: "[[reset_password:reset_password]]",
98	},
99	]),
100	title: "[[pages:reset]]",
101	});
102	}
103	};
104
105	Controllers.login = async function (req, res) {	4✔
106	const data = { loginFormEntry: [] };	44✔
107	const loginStrategies =
108	require("../routes/authentication").getLoginStrategies();	44✔
109	const registrationType = meta.config.registrationType \|\| "normal";	44!
110	const allowLoginWith = meta.config.allowLoginWith \|\| "username-email";	44✔
111
112	let errorText;
113	if (req.query.error === "csrf-invalid") {	44!
NEW 114	errorText = "[[error:csrf-invalid]]";	×
115	} else if (req.query.error) {	44!
116	errorText = validator.escape(String(req.query.error));	×
117	}
118
119	if (req.headers["x-return-to"]) {	44!
NEW 120	req.session.returnTo = req.headers["x-return-to"];	×
121	}
122
123	// Occasionally, x-return-to is passed a full url.
124	req.session.returnTo =	44✔
125	req.session.returnTo &&	44!
126	req.session.returnTo
127	.replace(nconf.get("base_url"), "")
128	.replace(nconf.get("relative_path"), "");
129
130	data.alternate_logins = loginStrategies.length > 0;	44✔
131	data.authentication = loginStrategies;	44✔
132	data.allowRegistration = registrationType === "normal";	44✔
133	data.allowLoginWith = `[[login:${allowLoginWith}]]`;	44✔
134	data.breadcrumbs = helpers.buildBreadcrumbs([	44✔
135	{
136	text: "[[global:login]]",
137	},
138	]);
139	data.error = req.flash("error")[0] \|\| errorText;	44✔
140	data.title = "[[pages:login]]";	44✔
141	data.allowPasswordReset = !meta.config["password:disableEdit"];	44✔
142
143	const hasLoginPrivilege = await privileges.global.canGroup(	44✔
144	"local:login",
145	"registered-users"
146	);
147	data.allowLocalLogin =	44✔
148	hasLoginPrivilege \|\| parseInt(req.query.local, 10) === 1;	44!
149
150	if (	44!
151	!data.allowLocalLogin &&	44!
152	!data.allowRegistration &&
153	data.alternate_logins &&
154	data.authentication.length === 1
155	) {
UNCOV 156	return helpers.redirect(res, { external: data.authentication[0].url });	×
157	}
158
159	// Re-auth challenge, pre-fill username
160	if (req.loggedIn) {	44!
NEW 161	const userData = await user.getUserFields(req.uid, ["username"]);	×
162	data.username = userData.username;	×
163	data.alternate_logins = false;	×
164	}
165	res.render("login", data);	44✔
166	};
167
168	Controllers.register = async function (req, res, next) {	4✔
169	const registrationType = meta.config.registrationType \|\| "normal";	4!
170
171	if (registrationType === "disabled") {	4!
172	return setImmediate(next);	×
173	}
174
175	let errorText;
176	const returnTo = (req.headers["x-return-to"] \|\| "").replace(	4✔
177	nconf.get("base_url") + nconf.get("relative_path"),
178	""
179	);
180	if (req.query.error === "csrf-invalid") {	4!
NEW 181	errorText = "[[error:csrf-invalid]]";	×
182	}
183	try {	4✔
184	if (	4!
185	registrationType === "invite-only" \|\|	8✔
186	registrationType === "admin-invite-only"
187	) {
188	try {	×
189	await user.verifyInvitation(req.query);	×
190	} catch (e) {
NEW 191	return res.render("400", {	×
192	error: e.message,
193	});
194	}
195	}
196
197	if (returnTo) {	4!
198	req.session.returnTo = returnTo;	×
199	}
200
201	const loginStrategies =
202	require("../routes/authentication").getLoginStrategies();	4✔
203	res.render("register", {	4✔
204	"register_window:spansize": loginStrategies.length	4!
205	? "col-md-6"
206	: "col-md-12",
207	alternate_logins: !!loginStrategies.length,
208	authentication: loginStrategies,
209
210	minimumUsernameLength: meta.config.minimumUsernameLength,
211	maximumUsernameLength: meta.config.maximumUsernameLength,
212	minimumPasswordLength: meta.config.minimumPasswordLength,
213	minimumPasswordStrength: meta.config.minimumPasswordStrength,
214	breadcrumbs: helpers.buildBreadcrumbs([
215	{
216	text: "[[register:register]]",
217	},
218	]),
219	regFormEntry: [
220	{
221	label: "Account Type",
222	styleName: "account-type",
223	html: `
224	<select class="form-control" name="account-type" aria-label="Account Type">
225	<option value="student" selected>Student</option>
226	<option value="instructor">Instructor</option>
227	<option value="recruiter">Recruiter</option>
228	</select>
229	`,
230	},
231	],
232	error: req.flash("error")[0] \|\| errorText,	8✔
233	title: "[[pages:register]]",
234	});
235	} catch (err) {
236	next(err);	×
237	}
238	};
239
240	Controllers.registerInterstitial = async function (req, res, next) {	4✔
241	if (!req.session.hasOwnProperty("registration")) {	12!
NEW 242	return res.redirect(`${nconf.get("relative_path")}/register`);	×
243	}
244	try {	12✔
245	const data = await plugins.hooks.fire("filter:register.interstitial", {	12✔
246	req,
247	userData: req.session.registration,
248	interstitials: [],
249	});
250
251	if (!data.interstitials.length) {	12!
252	// No interstitials, redirect to home
253	const returnTo =
NEW 254	req.session.returnTo \|\| req.session.registration.returnTo;	×
255	delete req.session.registration;	×
NEW 256	return helpers.redirect(res, returnTo \|\| "/");	×
257	}
258
259	const errors = req.flash("errors");	12✔
260	const renders = data.interstitials.map((interstitial) =>	12✔
261	req.app.renderAsync(interstitial.template, {	20✔
262	...(interstitial.data \|\| {}),	20!
263	errors,
264	})
265	);
266	const sections = await Promise.all(renders);	12✔
267
268	res.render("registerComplete", {	12✔
269	title: "[[pages:registration-complete]]",
270	register: data.userData.register,
271	sections,
272	errors,
273	});
274	} catch (err) {
275	next(err);	×
276	}
277	};
278
279	Controllers.confirmEmail = async (req, res, next) => {	4✔
280	try {	×
281	await user.email.confirmByCode(req.params.code, req.session.id);	×
282	} catch (e) {
NEW 283	if (e.message === "[[error:invalid-data]]") {	×
284	return next();	×
285	}
286
287	throw e;	×
288	}
289
NEW 290	res.render("confirm", {	×
291	title: "[[pages:confirm]]",
292	});
293	};
294
295	Controllers.robots = function (req, res) {	4✔
296	res.set("Content-Type", "text/plain");	8✔
297
298	if (meta.config["robots:txt"]) {	8!
NEW 299	res.send(meta.config["robots:txt"]);	×
300	} else {
301	res.send(	8✔
302	`${"User-agent: *\n" + "Disallow: "}${nconf.get(
303	"relative_path"
304	)}/admin/\n` +
305	`Disallow: ${nconf.get("relative_path")}/reset/\n` +
306	`Disallow: ${nconf.get("relative_path")}/compose\n` +
307	`Sitemap: ${nconf.get("url")}/sitemap.xml`
308	);
309	}
310	};
311
312	Controllers.manifest = async function (req, res) {	4✔
313	const manifest = {	4✔
314	name: meta.config.title \|\| "NodeBB",	4!
315	short_name: meta.config["title:short"] \|\| meta.config.title \|\| "NodeBB",	8!
316	start_url: nconf.get("url"),
317	display: "standalone",
318	orientation: "portrait",
319	theme_color: meta.config.themeColor \|\| "#ffffff",	8✔
320	background_color: meta.config.backgroundColor \|\| "#ffffff",	8✔
321	icons: [],
322	};
323
324	if (meta.config["brand:touchIcon"]) {	4!
NEW 325	manifest.icons.push(	×
326	{
327	src: `${nconf.get(
328	"relative_path"
329	)}/assets/uploads/system/touchicon-36.png`,
330	sizes: "36x36",
331	type: "image/png",
332	density: 0.75,
333	},
334	{
335	src: `${nconf.get(
336	"relative_path"
337	)}/assets/uploads/system/touchicon-48.png`,
338	sizes: "48x48",
339	type: "image/png",
340	density: 1.0,
341	},
342	{
343	src: `${nconf.get(
344	"relative_path"
345	)}/assets/uploads/system/touchicon-72.png`,
346	sizes: "72x72",
347	type: "image/png",
348	density: 1.5,
349	},
350	{
351	src: `${nconf.get(
352	"relative_path"
353	)}/assets/uploads/system/touchicon-96.png`,
354	sizes: "96x96",
355	type: "image/png",
356	density: 2.0,
357	},
358	{
359	src: `${nconf.get(
360	"relative_path"
361	)}/assets/uploads/system/touchicon-144.png`,
362	sizes: "144x144",
363	type: "image/png",
364	density: 3.0,
365	},
366	{
367	src: `${nconf.get(
368	"relative_path"
369	)}/assets/uploads/system/touchicon-192.png`,
370	sizes: "192x192",
371	type: "image/png",
372	density: 4.0,
373	},
374	{
375	src: `${nconf.get(
376	"relative_path"
377	)}/assets/uploads/system/touchicon-512.png`,
378	sizes: "512x512",
379	type: "image/png",
380	density: 10.0,
381	}
382	);
383	}
384
385	if (meta.config["brand:maskableIcon"]) {	4!
UNCOV 386	manifest.icons.push({	×
387	src: `${nconf.get(
388	"relative_path"
389	)}/assets/uploads/system/maskableicon-orig.png`,
390	type: "image/png",
391	purpose: "maskable",
392	});
393	} else if (meta.config["brand:touchIcon"]) {	4!
394	manifest.icons.push({	×
395	src: `${nconf.get(
396	"relative_path"
397	)}/assets/uploads/system/touchicon-orig.png`,
398	type: "image/png",
399	purpose: "maskable",
400	});
401	}
402
403	const data = await plugins.hooks.fire("filter:manifest.build", {	4✔
404	req: req,
405	res: res,
406	manifest: manifest,
407	});
408	res.status(200).json(data.manifest);	4✔
409	};
410
411	Controllers.outgoing = function (req, res, next) {	4✔
412	const url = req.query.url \|\| "";	16✔
413	const allowedProtocols = [	16✔
414	"http",
415	"https",
416	"ftp",
417	"ftps",
418	"mailto",
419	"news",
420	"irc",
421	"gopher",
422	"nntp",
423	"feed",
424	"telnet",
425	"mms",
426	"rtsp",
427	"svn",
428	"tel",
429	"fax",
430	"xmpp",
431	"webcal",
432	];
433	const parsed = require("url").parse(url);	16✔
434
435	if (	16✔
436	!url \|\|	36✔
437	!parsed.protocol \|\|
438	!allowedProtocols.includes(parsed.protocol.slice(0, -1))
439	) {
440	return next();	12✔
441	}
442
443	res.render("outgoing", {	4✔
444	outgoing: validator.escape(String(url)),
445	title: meta.config.title,
446	breadcrumbs: helpers.buildBreadcrumbs([
447	{
448	text: "[[notifications:outgoing_link]]",
449	},
450	]),
451	});
452	};
453
454	Controllers.termsOfUse = async function (req, res, next) {	4✔
455	if (!meta.config.termsOfUse) {	8✔
456	return next();	4✔
457	}
458	const termsOfUse = await plugins.hooks.fire("filter:parse.post", {	4✔
459	postData: {
460	content: meta.config.termsOfUse \|\| "",	4!
461	},
462	});
463	res.render("tos", {	4✔
464	termsOfUse: termsOfUse.postData.content,
465	});
466	};

CMU-17313Q / fall23-nodebb-the-powerpuff-girls / 6781993403

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous