super.controller.ts

import { Router, Request, Response, NextFunction } from 'express';
import userModel from '../model/user.model';
import IUser from '../interface/user.interface';
import Controller from '../interface/controller.interface';
import authMiddleware from '../middleware/auth.middleware';
import UserNotFoundException from '../exception/UserNotFoundException';
import HttpException from '../exception/HttpException';
import superMiddleware from '../middleware/super.middleware';
import AuthService from '../service/auth.service';
import logger from '../util/logger';
import { ANCHOR_PATH, COUNT_PATH, DISABLE_PATH, ID_PATH, REGISTER_PATH, SUPER_PATH, USER_PATH } from '../util/common';
import RequestWithUser from '../interface/requestWithUser.interface';
import { ANCHOR_LIMIT_MAX } from '../util/constants';
import AnchorService from '../service/anchor.service';
import mongoose from 'mongoose';

class SuperController implements Controller {
  public path = `/${SUPER_PATH}`;
  public router = Router();
  private userModel = userModel;
  private anchorService = new AnchorService();

  constructor() {
    this.initializeRoutes();
  }

  private initializeRoutes() {
    this.router.get(`${this.path}/${USER_PATH}/${ID_PATH}/:id`, authMiddleware, superMiddleware, this.getUserById);
    this.router.get(`${this.path}/${USER_PATH}`, authMiddleware, superMiddleware, this.getUsers);
    this.router.get(`${this.path}/${USER_PATH}/${COUNT_PATH}`, authMiddleware, superMiddleware, this.getUserCount);
    this.router.post(`${this.path}/${REGISTER_PATH}`, authMiddleware, superMiddleware, this.register);
    this.router.put(`${this.path}/${USER_PATH}/${ID_PATH}/:id`, authMiddleware, superMiddleware, this.updateUser);
    this.router.post(`${this.path}/${USER_PATH}/${DISABLE_PATH}/${ID_PATH}/:id`, authMiddleware, superMiddleware, this.disableUser);
    this.router.delete(`${this.path}/${USER_PATH}/${ID_PATH}/:id`, authMiddleware, superMiddleware, this.deleteUser);
    this.router.post(`${this.path}/${ANCHOR_PATH}`, authMiddleware, superMiddleware, this.anchor);
  }
  private getUserById = async (req: Request, res: Response, next: NextFunction) => {
    const user = await this.userModel.findById(req.params.id).populate('roles', '-_id -__v')
      .catch(() => {
        return next(new UserNotFoundException(req.params.id));
      });
    return res.status(200).json(user);
  }

  private getUsers = async (req: Request, res: Response, next: NextFunction) => {
    const users = await this.userModel.find({}).populate('roles', '-_id -__v')
      .catch((error: string) => {
        next(new UserNotFoundException(error));
      });
    return res.status(200).json(users);
  }

  private getUserCount = async (req: Request, res: Response, next: NextFunction) => {
    const userCount = await this.userModel.countDocuments({})
      .catch((error: string) => {
        next(new HttpException(400, error));
      });
    return res.status(200).json(userCount);
  }

  private register = async (req: Request, res: Response, next: NextFunction) => {
    const userData: IUser = req.body;
    const authService: AuthService = await AuthService.getInstance();
    const user = await authService.register(userData)
      .catch((error: string) => {
        next(new HttpException(400, error));
      });
    return res.status(201).json(user);
  }

  private updateUser = async (req: Request, res: Response, next: NextFunction) => {
    const userData: IUser = req.body;
    const user = await this.userModel.findOneAndUpdate({ _id: req.params.id }, { username: userData.username, password: userData.password })
      .catch((error: string) => {
        next(new HttpException(400, error));
      });
    return res.status(200).json(user);
  }

  private disableUser = async (req: Request, res: Response, next: NextFunction) => {
    const user = await this.userModel.findOneAndUpdate({ _id: req.params.id }, { enabled: false })
      .catch((error: string) => {
        next(new HttpException(400, error));
      });
    logger.log({ level: 'info', message: `user disabled: ${user}` });
    return res.status(200).json(user);
  }

  private deleteUser = async (req: Request, res: Response, next: NextFunction) => {
    const user = await this.userModel.findOneAndRemove({ _id: req.params.id })
      .catch((error: string) => {
        next(new HttpException(400, error));
      });
    return res.status(200).json(user);
  }

  private anchor = async (req: RequestWithUser, res: Response, next: NextFunction) => {
    if (!req.body.limit || isNaN(+req.body.limit) || req.body.limit < 1 || req.body.limit > ANCHOR_LIMIT_MAX) {
      return next(new HttpException(400, `Limit must be between 1 - ${ANCHOR_LIMIT_MAX}`));
    }
    const session = await mongoose.startSession();
    session.startTransaction();
    const ret = await this.anchorService.anchor(req.body.provider, req.body.limit)
      .catch((error: Error) => {
        console.log(`calling abort`);
        session.abortTransaction();
        session.endSession();
        next(new HttpException(400, error.message));
      });
    if (ret && ret.count > 0) {
      await session.commitTransaction();
      session.endSession();
      return res.status(200).json(ret);
    } else {
      await session.abortTransaction();
      session.endSession();
      return next(new HttpException(400, 'Anchor failed'));
    }
  };
}

export default SuperController;