Backend

// Старт сервера
app.use(function(req, res, next) {
  req.reqId = LogContext.getContext();
  MyLogger.log(req.reqId, fileName, req.url);
  next();
});

// body parser
app.use(
  bodyParser.json({
    limit: "5mb"
  })
);


app.use((req, res, next) => {
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set("requestId", uuid());
    next();
  });
});


app.use("/api", apiRouter);
app.use("/public", publicRouter);

app.use("/api/helpdesk", helpDeskApiRouter);
app.use("/public/helpdesk", helpDeskPublicRouter);


server.listen(environment.port, environment.host, function() {
  console.log(
    "Node server started on %s://%s:%d",
    environment.http_type,
    environment.host,
    environment.port
  );
});



// Роуетер экспресса
router.use(publicRoutes.CONFORM, require("../../users/conform/conform"));
router.use(publicRoutes.AUTH, require("../../users/auth/auth-router"));
router.use(publicRoutes.REGISTER, require("../../users/register/registration"));
router.use(publicRoutes.REFRESH, require("../../users/refresh/refresh-router"));
router.use(publicRoutes.RESTORE, require("../../users/restore/restore"));
router.use(publicRoutes.CHANGE_PASSWORD, require("../../users/change-password/changepassword"));

module.exports = router;

// Логика роутера экспресса

router.route("/").patch(refreshToken);

async function refreshToken(req, res) {
  let body;
  const myLogger = new MyLogger(req.reqId, fileName);
  try {
    const refreshLogic = new RefreshLogic(req.body.token, req.reqId);
    const token = await refreshLogic.refreshToken();
    body = requester.createBody({ token });
  } catch (error) {
    body = requester.createError(error);
    myLogger.myErrorLogger(error);
    myLogger.log("Send to user " + JSON.stringify(body));
  }

  res.json(body);
}


// Бизнес логика
class RefreshLogic extends CommonRefreshLogic {
  constructor(token, logId) {
    super(token, logId);
  }

  checkRole() {
    if (
      this.decodedToken.role !== myRoles.USER &&
      this.decodedToken.role !== myRoles.GUEST
    ) {
      const e = new MyError(errorCodes.INVALID_USER_ROLE, "");
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  async refreshToken() {
    try {
      this.myLogger.debug("refreshToken");
      this.validateToken();
      this.verifyToken();
      this.checkRole();
      await this.checkIsUserExist();
      await this.compareChange();
      await this.updateUserIdentity();
      const token = tokenGenerator.getToken(this.user);
      return token;
    } catch (e) {
      throw e;
    }
  }
}

// Test example

describe("Тестирование авторизации", function() {
  it("При успехе возращается токен", async () => {
    await request(server)
      .post("/public/auth")
      .send({
        email: "masquitos@mail.ru",
        password: "12345"
      })
      .expect(res => {
        assert.strictEqual(validator.isJWT(res.body.data.token), true);
      });
  });

  it(
    "При не верном логине/пароле возращается ошибка с текстом " +
      errorCodes.INVALID_USER_OR_PASSWORD.text,
    async () => {
      await request(server)
        .post("/public/auth")
        .send({
          email: "masquitos@mail.ru",
          password: "123456"
        })
        .expect(res => {
          assert.strictEqual(
            res.body.error.text,
            errorCodes.INVALID_USER_OR_PASSWORD.text
          );
        });
    }
  );
});

// socket.io get event

        socket.on(events.MESSAGES, async function(
          conversationsMessages,
          callback
        ) {
          try {
            const userId = socket.decoded_token.id;
            for (const convId of Object.keys(conversationsMessages)) {
              const conversationId = parseInt(convId, 10);
              const companion = await db_helper.getCompanion(
                userId,
                conversationId
              );
              const messages = conversationsMessages[conversationId];
              await db_helper.saveMessages(conversationId, userId, messages);
              const totalCount = await db_helper.getMessageTotalCount(
                conversationId
              );
              // Отправляем сообщение назад, что мы его получили.
              // Отправляем сообщения участнику чата
              messages.forEach(msg => {
                msg.totalCount = totalCount;
              });
              self.sendData(
                userId,
                companion.user_id,
                events.MESSAGES,
                messages
              );
            }

            callback(requester.createBody());
          } catch (error) {
            callback(requester.createError(error));
            console.error("Не могу сохранить сообщения пользователя", error);
          }
        });

// socket.io send data

  sendData(fromId, toId, event, data, logId) {
    const socket = this.getUserSocket(toId);
    if (socket) {
      socket.emit(event, data);
      MyLogger.log(logId, fileName, "event " + event);
    } else {
      if (event === events.MESSAGES) {
        mailWorker.sendNotifyMessage(fromId, toId, data);
      }
      if (event === events.TASK) {
        data.subscriptions.forEach(id =>
          mailWorker.sendNotifySubscriptions(toId, id, data.data)
        );
      }
    }
  }

// send email
  async sendNotifyMessage(fromUserId, toUserId, messages) {
    try {
      const dbFromUser = await dbHelper.getUserById(fromUserId);
      const dbToUser = await dbHelper.getUserById(toUserId);
      if (dbToUser.role === myRoles.USER) {
        const dbNotify = await dbHelper.getUserNotify(toUserId);
        const notify = parser.parseNotify(dbNotify);
        myLog.log(
          "try sendNotifyMessage",
          "from",
          fromUserId,
          "to",
          toUserId,
          notify
        );
        if (notify.isMessages) {
          myLog.log("sendNotifyMessage", notify);
          messages.forEach(el => {
            mailSender.sendNotifyMessage(
              dbFromUser.name,
              dbToUser.email,
              el.text
            );
          });
        }
      }
    } catch (e) {
      console.error("Error sendNotifyMessage : ", e.message);
    }
  }