8510901684

Committed 01 Apr 2024 04:53PM UTC coverage: 65.188% (+0.03%) from 65.162%

Build # 8510901684

Build Type

Pull #870

github

Committed by

web-flow

Commit Message

Merge fcc123bb1 into 6c53aca7e

Pull Request Pull Request #870: Feature/caption and title (#14)

Run Details

1549 of 2694 branches covered (57.5%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

6 existing lines in 2 files now uncovered.

4417 of 6458 relevant lines covered (68.4%)

13349.83 hits per line

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

40.48

/src/backend/middlewares/RenderingMWs.ts

import {NextFunction, Request, Response} from 'express';
import {ErrorCodes, ErrorDTO} from '../../common/entities/Error';
import {Message} from '../../common/entities/Message';
import {PrivateConfigClass} from '../../common/config/private/PrivateConfigClass';
import {UserDTO, UserRoles} from '../../common/entities/UserDTO';
import {NotificationManager} from '../model/NotifocationManager';
import {Logger} from '../Logger';
import {SharingDTO} from '../../common/entities/SharingDTO';
import {Utils} from '../../common/Utils';
import {LoggerRouter} from '../routes/LoggerRouter';
import {TAGS} from '../../common/config/public/ClientConfig';
import {ExtensionConfigWrapper} from '../model/extension/ExtensionConfigWrapper';

const forcedDebug = process.env['NODE_ENV'] === 'debug';

export class RenderingMWs {
  public static renderResult(
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (typeof req.resultPipe === 'undefined') {
      return next();
    }

    return RenderingMWs.renderMessage(res, req.resultPipe);
  }

  public static renderSessionUser(
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (!req.session['user']) {
      return next(new ErrorDTO(ErrorCodes.GENERAL_ERROR, 'User not exists'));
    }

    const user = {
      id: req.session['user'].id,
      name: req.session['user'].name,
      csrfToken: req.session['user'].csrfToken || req.csrfToken(),
      role: req.session['user'].role,
      usedSharingKey: req.session['user'].usedSharingKey,
      permissions: req.session['user'].permissions,
    } as UserDTO;

    if (!user.csrfToken && req.csrfToken) {
      user.csrfToken = req.csrfToken();
    }

    RenderingMWs.renderMessage(res, user);
  }

  public static renderSharing(
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (!req.resultPipe) {
      return next();
    }

    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    const {password, creator, ...sharing} = req.resultPipe as SharingDTO;
    RenderingMWs.renderMessage(res, sharing);
  }

  public static renderSharingList(
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (!req.resultPipe) {
      return next();
    }

    const shares = Utils.clone(req.resultPipe as SharingDTO[]);
    shares.forEach((s): void => {
      delete s.password;
      delete s.creator.password;
    });
    return RenderingMWs.renderMessage(res, shares);
  }

  public static renderFile(
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (!req.resultPipe) {
      return next();
    }
    return res.sendFile(req.resultPipe as string, {
      maxAge: 31536000,
      dotfiles: 'allow',
    });
  }

  public static renderOK(
    req: Request,
    res: Response
  ): void {
    const message = new Message<string>(null, 'ok');
    res.json(message);
  }

  public static async renderConfig(
    req: Request,
    res: Response
  ): Promise<void> {
    const originalConf = await ExtensionConfigWrapper.original();
    // These are sensitive information, do not send to the client side
    originalConf.Server.sessionSecret = null;
    const originalConfJSON = JSON.parse(JSON.stringify(originalConf.toJSON({
      attachState: true,
      attachVolatile: true,
      skipTags: {secret: true} as TAGS
    }) as PrivateConfigClass));

    const message = new Message<PrivateConfigClass>(
      null,
      originalConfJSON
    );
    res.json(message);
  }

  public static renderError(
    err: Error,
    req: Request,
    res: Response,
    next: NextFunction
  ): void {
    if (err instanceof ErrorDTO) {
      if (err.details) {
        const logFn = Logger.logLevelForError(err.code)
        LoggerRouter.log(logFn, req, res);
        // use separate rendering for detailsStr
        const d = err.detailsStr;
        delete err.detailsStr;
        logFn(err);
        err.detailsStr = d;
        delete err.details; // do not send back error object to the client side

        // hide error details for non developers
        if (
          !(
            forcedDebug ||
            (req.session &&
              req.session['user'] &&
              req.session['user'].role >= UserRoles.Developer)
          )
        ) {
          delete err.detailsStr;
        }
      }
      const message = new Message<null>(err, null);
      res.json(message);
      return;
    }
    NotificationManager.error('Unknown server error', err, req);
    return next(err);
  }

  protected static renderMessage<T>(res: Response, content: T): void {
    const message = new Message<T>(null, content);
    res.json(message);
  }
}

1	import {NextFunction, Request, Response} from 'express';
2	import {ErrorCodes, ErrorDTO} from '../../common/entities/Error';	1✔
3	import {Message} from '../../common/entities/Message';	1✔
4	import {PrivateConfigClass} from '../../common/config/private/PrivateConfigClass';
5	import {UserDTO, UserRoles} from '../../common/entities/UserDTO';	1✔
6	import {NotificationManager} from '../model/NotifocationManager';	1✔
7	import {Logger} from '../Logger';	1✔
8	import {SharingDTO} from '../../common/entities/SharingDTO';
9	import {Utils} from '../../common/Utils';	1✔
10	import {LoggerRouter} from '../routes/LoggerRouter';	1✔
11	import {TAGS} from '../../common/config/public/ClientConfig';
12	import {ExtensionConfigWrapper} from '../model/extension/ExtensionConfigWrapper';	1✔
13
14	const forcedDebug = process.env['NODE_ENV'] === 'debug';	1✔
15
16	export class RenderingMWs {	1✔
17	public static renderResult(
18	req: Request,
19	res: Response,
20	next: NextFunction
21	): void {
22	if (typeof req.resultPipe === 'undefined') {	6!
23	return next();	×
24	}
25
26	return RenderingMWs.renderMessage(res, req.resultPipe);	6✔
27	}
28
29	public static renderSessionUser(
30	req: Request,
31	res: Response,
32	next: NextFunction
33	): void {
34	if (!req.session['user']) {	10!
35	return next(new ErrorDTO(ErrorCodes.GENERAL_ERROR, 'User not exists'));	×
36	}
37
38	const user = {	10✔
39	id: req.session['user'].id,
40	name: req.session['user'].name,
41	csrfToken: req.session['user'].csrfToken \|\| req.csrfToken(),	20✔
42	role: req.session['user'].role,
43	usedSharingKey: req.session['user'].usedSharingKey,
44	permissions: req.session['user'].permissions,
45	} as UserDTO;
46
47	if (!user.csrfToken && req.csrfToken) {	10!
48	user.csrfToken = req.csrfToken();	×
49	}
50
51	RenderingMWs.renderMessage(res, user);	10✔
52	}
53
54	public static renderSharing(
55	req: Request,
56	res: Response,
57	next: NextFunction
58	): void {
59	if (!req.resultPipe) {	×
60	return next();	×
61	}
62
63	// eslint-disable-next-line @typescript-eslint/no-unused-vars
64	const {password, creator, ...sharing} = req.resultPipe as SharingDTO;	×
65	RenderingMWs.renderMessage(res, sharing);	×
66	}
67
68	public static renderSharingList(
69	req: Request,
70	res: Response,
71	next: NextFunction
72	): void {
73	if (!req.resultPipe) {	×
74	return next();	×
75	}
76
77	const shares = Utils.clone(req.resultPipe as SharingDTO[]);	×
78	shares.forEach((s): void => {	×
79	delete s.password;	×
80	delete s.creator.password;	×
81	});
82	return RenderingMWs.renderMessage(res, shares);	×
83	}
84
85	public static renderFile(
86	req: Request,
87	res: Response,
88	next: NextFunction
89	): void {
90	if (!req.resultPipe) {	2!
91	return next();	×
92	}
93	return res.sendFile(req.resultPipe as string, {	2✔
94	maxAge: 31536000,
95	dotfiles: 'allow',
96	});
97	}
98
99	public static renderOK(
100	req: Request,
101	res: Response
102	): void {
103	const message = new Message<string>(null, 'ok');	×
104	res.json(message);	×
105	}
106
107	public static async renderConfig(
108	req: Request,
109	res: Response
110	): Promise<void> {
111	const originalConf = await ExtensionConfigWrapper.original();	×
112	// These are sensitive information, do not send to the client side
113	originalConf.Server.sessionSecret = null;	×
114	const originalConfJSON = JSON.parse(JSON.stringify(originalConf.toJSON({	×
115	attachState: true,
116	attachVolatile: true,
117	skipTags: {secret: true} as TAGS
118	}) as PrivateConfigClass));
119
120	const message = new Message<PrivateConfigClass>(	×
121	null,
122	originalConfJSON
123	);
124	res.json(message);	×
125	}
126
127	public static renderError(
128	err: Error,
129	req: Request,
130	res: Response,
131	next: NextFunction
132	): void {
133	if (err instanceof ErrorDTO) {	4!
134	if (err.details) {	4!
135	const logFn = Logger.logLevelForError(err.code)	×
136	LoggerRouter.log(logFn, req, res);	×
137	// use separate rendering for detailsStr
138	const d = err.detailsStr;	×
139	delete err.detailsStr;	×
140	logFn(err);	×
141	err.detailsStr = d;	×
142	delete err.details; // do not send back error object to the client side	×
143
144	// hide error details for non developers
145	if (	×
146	!(
147	forcedDebug \|\|	×
148	(req.session &&
149	req.session['user'] &&
150	req.session['user'].role >= UserRoles.Developer)
151	)
152	) {
UNCOV 153	delete err.detailsStr;	×
154	}
155	}
156	const message = new Message<null>(err, null);	4✔
157	res.json(message);	4✔
158	return;	4✔
159	}
160	NotificationManager.error('Unknown server error', err, req);	×
UNCOV 161	return next(err);	×
162	}
163
164	protected static renderMessage<T>(res: Response, content: T): void {
165	const message = new Message<T>(null, content);	16✔
166	res.json(message);	16✔
167	}
168	}

bpatrik / pigallery2 / 8510901684

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