Revert "Merge master (#262)"

This reverts commit 0dc5962.

Author: Suboyyy

.env.example

@@ -27,15 +27,13 @@ DATABASE_URL=mysql://root:root@localhost/arena
 # Used in mail templates
 ARENA_WEBSITE=http://localhost:8080
 
+# SMTP server address (smtp://user:password@host(:port)?)
 # You can use Nodemailer App (https://nodemailer.com/app/) or mailtrap.io to test the emails
-EMAIL_HOST=
-EMAIL_PORT=
-EMAIL_SECURE=
-EMAIL_SENDER_NAME=
-EMAIL_SENDER_ADDRESS=
-EMAIL_AUTH_USER=
-EMAIL_AUTH_PASSWORD=
-EMAIL_REJECT_UNAUTHORIZED=
+SMTP_URI=smtp://user:pass@address:25/?pool=true&maxConnections=1
+GMAIL=false
+GMAIL_USERNAME=[email protected]
+GMAIL_PASSWORD=
+MAX_MAILS_PER_BATCH=100
 
 # Used to give a discount on tickets
 PARTNER_MAILS=utt.fr,utc.fr,utbm.fr

src/controllers/admin/emails/index.ts

@@ -1,14 +1,10 @@
 import { Router } from 'express';
 import getMails from './getMails';
 import send from './send';
-import sendTemplate from './sendTemplate';
-import sendCustom from './sendCustom';
 
 const router = Router();
 
 router.get('/', getMails);
 router.post('/', send);
-router.post('/template', sendTemplate);
-router.post('/custom', sendCustom);
 
 export default router;

src/controllers/admin/emails/send.ts

@@ -1,9 +1,13 @@
+/* eslint-disable unicorn/no-nested-ternary */
 import { NextFunction, Request, Response } from 'express';
 import Joi from 'joi';
+import { badRequest, created } from '../../../utils/responses';
 import { hasPermission } from '../../../middlewares/authentication';
-import { Error as ApiError, MailGeneralQuery } from '../../../types';
+import { Error as ApiError, MailQuery } from '../../../types';
 import { validateBody } from '../../../middlewares/validation';
-import { sendGeneralMail } from '../../../services/email';
+import { sendEmail, SerializedMail } from '../../../services/email';
+import { serialize } from '../../../services/email/serializer';
+import database from '../../../services/database';
 import { getRequestInfo } from '../../../utils/users';
 
 export default [
@@ -12,7 +16,23 @@ export default [
   validateBody(
     Joi.object({
       preview: Joi.boolean().default(false),
-      generalMail: Joi.string().required(),
+      locked: Joi.boolean().optional(),
+      tournamentId: Joi.string().optional(),
+      subject: Joi.string().required(),
+      highlight: Joi.object({
+        title: Joi.string().required(),
+        intro: Joi.string().required(),
+      }).required(),
+      reason: Joi.string().optional(),
+      content: Joi.array()
+        .items(
+          Joi.object({
+            title: Joi.string().required(),
+            components: Joi.array().required(),
+          }).required(),
+        )
+        .required()
+        .error(new Error(ApiError.MalformedMailBody)),
     }).error(
       (errors) =>
         errors.find((error) => error.message === ApiError.MalformedMailBody) ?? new Error(ApiError.InvalidMailOptions),
@@ -22,13 +42,100 @@ export default [
   // Controller
   async (request: Request, response: Response, next: NextFunction) => {
     try {
-      const mail = request.body as MailGeneralQuery;
+      const mail = request.body as MailQuery;
       const { user } = getRequestInfo(response);
 
-      const nbMailSent = await sendGeneralMail(mail.generalMail, mail.preview ? user : null);
+      // Find mail adresses to send the mail to
+      const mails = await database.user
+        .findMany({
+          where: {
+            registerToken: null,
+            email: {
+              not: null,
+            },
+            ...(mail.preview
+              ? {
+                  id: user.id,
+                }
+              : {
+                  team: {
+                    ...(mail.locked
+                      ? {
+                          NOT: {
+                            lockedAt: null,
+                          },
+                        }
+                      : mail.locked === false
+                        ? { lockedAt: null }
+                        : {}),
+                    tournamentId: mail.tournamentId,
+                  },
+                }),
+          },
+          select: {
+            email: true,
+          },
+        })
+        .then((mailWrappers) => mailWrappers.map((mailWrapper) => mailWrapper.email));
 
-      // TODO: change return to a created response
-      return response.json({ message: `Sent ${nbMailSent} emails` });
+      // Parallelize mails as it may take time
+      // As every mail is generated on a user basis, we cannot catch
+      // a mail format error as simply as usual. This is the reason
+      // why we track the status of all sent mails.
+      // If all mails are errored due to invalid syntax, it is most
+      // likely that the sender did a mistake.
+      const outgoingMails = await Promise.allSettled(
+        mails.map(async (adress) => {
+          let mailContent: SerializedMail;
+          try {
+            mailContent = await serialize({
+              sections: mail.content,
+              reason: mail.reason,
+              title: {
+                banner: mail.subject,
+                highlight: mail.highlight.title,
+                short: mail.highlight.intro,
+                topic: mail.preview ? `[PREVIEW]: ${mail.subject}` : mail.subject,
+              },
+              receiver: adress,
+            });
+          } catch {
+            throw ApiError.MalformedMailBody;
+          }
+          return sendEmail(mailContent);
+        }),
+      );
+
+      // Counts mail statuses
+      const results = outgoingMails.reduce(
+        (result, state) => {
+          if (state.status === 'fulfilled')
+            return {
+              ...result,
+              delivered: result.delivered + 1,
+            };
+          if (state.reason === ApiError.MalformedMailBody)
+            return {
+              ...result,
+              malformed: result.malformed + 1,
+            };
+          return {
+            ...result,
+            undelivered: result.undelivered + 1,
+          };
+        },
+        { malformed: 0, delivered: 0, undelivered: 0 },
+      );
+
+      // Respond to the request with the appropriate response code
+      if (results.malformed && !results.delivered && !results.undelivered)
+        return badRequest(response, ApiError.MalformedMailBody);
+
+      if (results.delivered || !results.undelivered) return created(response, results);
+
+      throw (<PromiseRejectedResult>(
+        outgoingMails.find((result) => result.status === 'rejected' && result.reason !== ApiError.MalformedMailBody)
+      )).reason;
     } catch (error) {
       return next(error);
     }

src/controllers/admin/emails/sendCustom.ts

@@ -4,7 +4,7 @@ import * as Sentry from '@sentry/node';
 import { isNotAuthenticated } from '../../middlewares/authentication';
 import { validateBody } from '../../middlewares/validation';
 import { fetchUser, generateResetToken } from '../../operations/user';
-import { sendMailsFromTemplate } from '../../services/email';
+import { sendPasswordReset } from '../../services/email';
 import { noContent } from '../../utils/responses';
 import * as validators from '../../utils/validators';
 import logger from '../../utils/logger';
@@ -37,7 +37,7 @@ export default [
         // Don't wait for mail to be sent as it could take time
         // We suppose here that is will pass. If it is not the case, error is
         // reported through Sentry and staff may resend the email manually
-        sendMailsFromTemplate('passwordreset', [userWithToken]).catch((error) => {
+        sendPasswordReset(userWithToken).catch((error) => {
           logger.error(error);
           Sentry.captureException(error, {
             user: {