582325497

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/ufersa/plataforma-sabia/commit/<a class=hub.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://git"><a class=hub.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://git"><a class=hub.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637d4e">c80e63a79<a href="https://github.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637d4e">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637d4e&quot;&gt;c80e63a79&lt;/a&gt;&lt;a href=&quot;https://github.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637d4e&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb9&lt;/a&gt;6b637d4e&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://github.com/ufersa/plataforma-sabia/commit/fd0cf28106bbc21bfca840362e4262dc89bd40bb">fd0cf2810</a><a href="https://github.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637d4e">&amp;quot;&amp;gt;fd0cf2810&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;fd0cf2810&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/c80e63a79b4d4ce031bbd21f9ae7bcb96b637&lt;/a&gt;d4e&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://github.com/ufersa/plataforma-sabia/commit/27c7d569d">27c7d569d">27c7d569d</a>

Pull Request Pull Request #836: Service Bookmarks

Run Details

1669 of 4634 branches covered (36.02%)

Branch coverage included in aggregate %.

67 of 67 new or added lines in 9 files covered. (100.0%)

7069 of 10841 relevant lines covered (65.21%)

20.28 hits per line

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

73.58

/packages/api/app/Controllers/Http/AuthController.js

/** @typedef {import('@adonisjs/framework/src/Request')} Request */
/** @typedef {import('@adonisjs/framework/src/Response')} Response */

const User = use('App/Models/User');

const Config = use('Adonis/Src/Config');
const Token = use('App/Models/Token');
const Bull = use('Rocketseat/Bull');
const SendMailJob = use('App/Jobs/SendMail');

const { errors, errorPayload } = require('../../Utils');

class AuthController {
        /**
         * Register an user.
         *
         * @param {Request} request The HTTP request
         * @param {object} user user
         * @param {string} scope scope
         */
        async sendEmailConfirmation(request, user, scope) {
                const { adminURL, webURL } = Config.get('app');
                await user
                        .tokens('type', 'confirm_ac')
                        .where('is_revoked', false)
                        .update({ is_revoked: true });

                const { token } = await user.generateToken('confirm-ac');

                const mailData = {
                        email: user.email,
                        subject: request.antl('message.auth.confirmAccountEmailSubject'),
                        template: 'emails.confirm-account',
                        user,
                        token,
                        url:
                                scope === 'admin'
                                        ? `${adminURL}/auth/confirm-account/`
                                        : `${webURL}?action=confirmAccount`,
                };
                Bull.add(SendMailJob.key, mailData, { attempts: 3 });
        }

        async register({ request }) {
                const { scope, disclaimers } = request.only(['scope', 'disclaimers']);
                const data = request.only(['full_name', 'first_name', 'last_name', 'email', 'password']);

                const user = await User.create(data);
                await user.load('role');
                await user.accept(disclaimers);
                await this.sendEmailConfirmation(request, user, scope);

                return {
                        ...user.toJSON(),
                        password: '',
                };
        }

        async confirmAccount({ request, response }) {
                const { token, scope } = request.only(['token', 'scope']);
                const { adminURL, webURL } = Config.get('app');

                const tokenObject = await Token.getTokenObjectFor(token, 'confirm-ac');

                if (!tokenObject) {
                        return response
                                .status(401)
                                .send(errorPayload(errors.INVALID_TOKEN, request.antl('error.auth.invalidToken')));
                }

                await tokenObject.revoke();

                const user = await tokenObject.user().fetch();

                user.status = 'verified';
                await user.save();

                const mailData = {
                        email: user.email,
                        subject: request.antl('message.auth.accountActivatedEmailSubject'),
                        template: 'emails.active-account',
                        user,
                        url: scope === 'admin' ? adminURL : webURL,
                };
                Bull.add(SendMailJob.key, mailData, { attempts: 3 });

                return response.status(200).send({ success: true });
        }

        /**
         * Register a confirmation e-mail.
         *
         * @param {Request} ctx.request The HTTP request
         *
         * @returns {Response}
         */

        async resendConfirmationEmail({ request, response }) {
                const { email, scope } = request.only(['email', 'scope']);
                const user = await User.findBy('email', email);

                if (user.isVerified()) {
                        return response.status(200).send({ success: true });
                }

                await this.sendEmailConfirmation(request, user, scope);

                return response.status(200).send({ success: true });
        }

        /**
         * Authenticate an user.
         *
         * @param {object} ctx The content of the request
         * @param {Request} ctx.request The HTTP request
         * @param {object} ctx.auth The Auth object.
         *
         * @returns {Response}
         */
        async auth({ request, auth, response }) {
                const { email, password } = request.only(['email', 'password']);

                const user = await User.findBy('email', email);
                if (user && (user.isPending() || user.isInvited())) {
                        return response
                                .status(401)
                                .send(
                                        errorPayload(
                                                errors.UNVERIFIED_EMAIL,
                                                request.antl('error.auth.unverifiedEmail'),
                                        ),
                                );
                }

                const token = await auth.attempt(email, password);
                return token;
        }

        /**
         * Method to handle restting passwords.
         *
         * @param {object} ctx The content of the request
         * @param {Request} ctx.request The HTTP request
         * @param {object} ctx.auth The Auth object.
         *
         * @returns {Response}
         */
        async forgotPassword({ request, response }) {
                const { email, scope } = request.all();

                const user = await User.findBy('email', email);

                if (!user) {
                        return response
                                .status(400)
                                .send(errorPayload(errors.INVALID_EMAIL, request.antl('error.email.invalid')));
                }

                await user
                        .tokens('type', 'reset-pw')
                        .where('is_revoked', false)
                        .update({ is_revoked: true });

                const { token } = await user.generateToken('reset-pw');
                const { adminURL, webURL } = Config.get('app');

                const mailData = {
                        email: user.email,
                        subject: request.antl('message.auth.passwordRecoveryEmailSubject'),
                        template: 'emails.forgot-password',
                        user,
                        token,
                        url:
                                scope === 'admin'
                                        ? `${adminURL}#/auth/reset-password`
                                        : `${webURL}/auth/reset-password`,
                };
                Bull.add(SendMailJob.key, mailData, { attempts: 3 });

                return response.status(200).send({ success: true });
        }

        /**
         * Resets a password through a token
         *
         * @param {object} ctx The content of the request
         * @param {Request} ctx.request The HTTP request
         * @param {object} ctx.auth The Auth object.
         *
         * @returns {Response}
         */
        async resetPassword({ request, response }) {
                const { token, password } = request.all();

                const tokenObject = await Token.getTokenObjectFor(token, 'reset-pw');

                if (!tokenObject) {
                        return response
                                .status(401)
                                .send(errorPayload(errors.INVALID_TOKEN, request.antl('error.auth.invalidToken')));
                }

                await tokenObject.revoke();

                const user = await tokenObject.user().fetch();
                user.merge({ password, status: 'verified' });
                await user.save();

                const mailData = {
                        email: user.email,
                        subject: request.antl('message.auth.passwordChangedEmailSubject'),
                        template: 'emails.reset-password',
                        user,
                };
                Bull.add(SendMailJob.key, mailData, { attempts: 3 });

                return response.status(200).send({ success: true });
        }

        /**
         * Returns the current logged in user.
         *
         * @param {object} ctx The content of the request
         * @param {Request} ctx.request The HTTP request
         * @param {object} ctx.auth The Auth object.
         *
         * @returns {Response}
         */
        async getMe({ auth, request }) {
                const filters = request.all();

                const user = await auth.current.user;
                await user.load('role');

                if (!!filters.bookmarks || filters.bookmarks === '') {
                        await user.load('bookmarks', (builder) => builder.select('id'));
                }

                if (!!filters.serviceBookmarks || filters.serviceBookmarks === '') {
                        await user.load('serviceBookmarks', (builder) => builder.select('id'));
                }

                if (!!filters.orders || filters.orders === '') {
                        await user.load('orders', (orders) => orders.with('technology.users'));
                }

                const operations = await user.getOperations();

                return { ...user.toJSON(), operations };
        }
}

module.exports = AuthController;

1	/** @typedef {import('@adonisjs/framework/src/Request')} Request */
2	/** @typedef {import('@adonisjs/framework/src/Response')} Response */
3
4	const User = use('App/Models/User');	2✔
5
6	const Config = use('Adonis/Src/Config');	2✔
7	const Token = use('App/Models/Token');	2✔
8	const Bull = use('Rocketseat/Bull');	2✔
9	const SendMailJob = use('App/Jobs/SendMail');	2✔
10
11	const { errors, errorPayload } = require('../../Utils');	2✔
12
13	class AuthController {
14	/**
15	* Register an user.
16	*
17	* @param {Request} request The HTTP request
18	* @param {object} user user
19	* @param {string} scope scope
20	*/
21	async sendEmailConfirmation(request, user, scope) {
22	const { adminURL, webURL } = Config.get('app');	3✔
23	await user	3✔
24	.tokens('type', 'confirm_ac')
25	.where('is_revoked', false)
26	.update({ is_revoked: true });
27
28	const { token } = await user.generateToken('confirm-ac');	3✔
29
30	const mailData = {	3✔
31	email: user.email,
32	subject: request.antl('message.auth.confirmAccountEmailSubject'),
33	template: 'emails.confirm-account',
34	user,
35	token,
36	url:
37	scope === 'admin'	3!
38	? `${adminURL}/auth/confirm-account/`
39	: `${webURL}?action=confirmAccount`,
40	};
41	Bull.add(SendMailJob.key, mailData, { attempts: 3 });	3✔
42	}
43
44	async register({ request }) {
45	const { scope, disclaimers } = request.only(['scope', 'disclaimers']);	3✔
46	const data = request.only(['full_name', 'first_name', 'last_name', 'email', 'password']);	3✔
47
48	const user = await User.create(data);	3✔
49	await user.load('role');	3✔
50	await user.accept(disclaimers);	3✔
51	await this.sendEmailConfirmation(request, user, scope);	3✔
52
53	return {	3✔
54	...user.toJSON(),
55	password: '',
56	};
57	}
58
59	async confirmAccount({ request, response }) {
60	const { token, scope } = request.only(['token', 'scope']);	×
61	const { adminURL, webURL } = Config.get('app');	×
62
63	const tokenObject = await Token.getTokenObjectFor(token, 'confirm-ac');	×
64
65	if (!tokenObject) {	×
66	return response	×
67	.status(401)
68	.send(errorPayload(errors.INVALID_TOKEN, request.antl('error.auth.invalidToken')));
69	}
70
71	await tokenObject.revoke();	×
72
73	const user = await tokenObject.user().fetch();	×
74
75	user.status = 'verified';	×
76	await user.save();	×
77
78	const mailData = {	×
79	email: user.email,
80	subject: request.antl('message.auth.accountActivatedEmailSubject'),
81	template: 'emails.active-account',
82	user,
83	url: scope === 'admin' ? adminURL : webURL,	×
84	};
85	Bull.add(SendMailJob.key, mailData, { attempts: 3 });	×
86
87	return response.status(200).send({ success: true });	×
88	}
89
90	/**
91	* Register a confirmation e-mail.
92	*
93	* @param {Request} ctx.request The HTTP request
94	*
95	* @returns {Response}
96	*/
97
98	async resendConfirmationEmail({ request, response }) {
99	const { email, scope } = request.only(['email', 'scope']);	×
100	const user = await User.findBy('email', email);	×
101
102	if (user.isVerified()) {	×
103	return response.status(200).send({ success: true });	×
104	}
105
106	await this.sendEmailConfirmation(request, user, scope);	×
107
108	return response.status(200).send({ success: true });	×
109	}
110
111	/**
112	* Authenticate an user.
113	*
114	* @param {object} ctx The content of the request
115	* @param {Request} ctx.request The HTTP request
116	* @param {object} ctx.auth The Auth object.
117	*
118	* @returns {Response}
119	*/
120	async auth({ request, auth, response }) {
121	const { email, password } = request.only(['email', 'password']);	32✔
122
123	const user = await User.findBy('email', email);	32✔
124	if (user && (user.isPending() \|\| user.isInvited())) {	32✔
125	return response	2✔
126	.status(401)
127	.send(
128	errorPayload(
129	errors.UNVERIFIED_EMAIL,
130	request.antl('error.auth.unverifiedEmail'),
131	),
132	);
133	}
134
135	const token = await auth.attempt(email, password);	30✔
136	return token;	26✔
137	}
138
139	/**
140	* Method to handle restting passwords.
141	*
142	* @param {object} ctx The content of the request
143	* @param {Request} ctx.request The HTTP request
144	* @param {object} ctx.auth The Auth object.
145	*
146	* @returns {Response}
147	*/
148	async forgotPassword({ request, response }) {
149	const { email, scope } = request.all();	4✔
150
151	const user = await User.findBy('email', email);	4✔
152
153	if (!user) {	4✔
154	return response	1✔
155	.status(400)
156	.send(errorPayload(errors.INVALID_EMAIL, request.antl('error.email.invalid')));
157	}
158
159	await user	3✔
160	.tokens('type', 'reset-pw')
161	.where('is_revoked', false)
162	.update({ is_revoked: true });
163
164	const { token } = await user.generateToken('reset-pw');	3✔
165	const { adminURL, webURL } = Config.get('app');	3✔
166
167	const mailData = {	3✔
168	email: user.email,
169	subject: request.antl('message.auth.passwordRecoveryEmailSubject'),
170	template: 'emails.forgot-password',
171	user,
172	token,
173	url:
174	scope === 'admin'	3!
175	? `${adminURL}#/auth/reset-password`
176	: `${webURL}/auth/reset-password`,
177	};
178	Bull.add(SendMailJob.key, mailData, { attempts: 3 });	3✔
179
180	return response.status(200).send({ success: true });	3✔
181	}
182
183	/**
184	* Resets a password through a token
185	*
186	* @param {object} ctx The content of the request
187	* @param {Request} ctx.request The HTTP request
188	* @param {object} ctx.auth The Auth object.
189	*
190	* @returns {Response}
191	*/
192	async resetPassword({ request, response }) {
193	const { token, password } = request.all();	5✔
194
195	const tokenObject = await Token.getTokenObjectFor(token, 'reset-pw');	5✔
196
197	if (!tokenObject) {	5✔
198	return response	4✔
199	.status(401)
200	.send(errorPayload(errors.INVALID_TOKEN, request.antl('error.auth.invalidToken')));
201	}
202
203	await tokenObject.revoke();	1✔
204
205	const user = await tokenObject.user().fetch();	1✔
206	user.merge({ password, status: 'verified' });	1✔
207	await user.save();	1✔
208
209	const mailData = {	1✔
210	email: user.email,
211	subject: request.antl('message.auth.passwordChangedEmailSubject'),
212	template: 'emails.reset-password',
213	user,
214	};
215	Bull.add(SendMailJob.key, mailData, { attempts: 3 });	1✔
216
217	return response.status(200).send({ success: true });	1✔
218	}
219
220	/**
221	* Returns the current logged in user.
222	*
223	* @param {object} ctx The content of the request
224	* @param {Request} ctx.request The HTTP request
225	* @param {object} ctx.auth The Auth object.
226	*
227	* @returns {Response}
228	*/
229	async getMe({ auth, request }) {
230	const filters = request.all();	34✔
231
232	const user = await auth.current.user;	34✔
233	await user.load('role');	34✔
234
235	if (!!filters.bookmarks \|\| filters.bookmarks === '') {	34✔
236	await user.load('bookmarks', (builder) => builder.select('id'));	33✔
237	}
238
239	if (!!filters.serviceBookmarks \|\| filters.serviceBookmarks === '') {	34!
240	await user.load('serviceBookmarks', (builder) => builder.select('id'));	×
241	}
242
243	if (!!filters.orders \|\| filters.orders === '') {	34✔
244	await user.load('orders', (orders) => orders.with('technology.users'));	24✔
245	}
246
247	const operations = await user.getOperations();	34✔
248
249	return { ...user.toJSON(), operations };	34✔
250	}
251	}
252
253	module.exports = AuthController;	2✔

ufersa / plataforma-sabia / 582325497

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