userlogin.controller.js

import config from 'config';
import ejwt from '../../../helper/encrypted-jwt';
import logger from '../../../helper/logger';
import * as Response from '../../../helper/responses';
import * as util from '../../../helper/util';
import { confirmRefreshToken } from '../../../helper/refresh';
import * as validate from '../../../helper/validate';
import { create as createLog } from '../../service/user/userlog.service';
import * as loginService from '../../service/user/userlogin.service';

// userType
const USER_TYPE = {
  DEMO: 15040,
  GUEST: 15030,
  USER: 15020,
  SUPPLIER: 15010,
  ADMIN: 15000
}

const USER_TYPE_NAV_MAPPER = {
  [USER_TYPE.ADMIN]: { path: '/admins' },
  [USER_TYPE.SUPPLIER]: { path: '/myyarns?page=1' },
  [USER_TYPE.DEMO]: { path: '/pr-supplier' },
  [USER_TYPE.USER]: { path: '/search' },
  [USER_TYPE.GUEST]: { path: '/pr-supplier' }
}

/**
 * login userlogin
 *
 * @param   {Object} req
 * @param   {Object} res
 * @returns {Object}
 */
export const login = async (req, res) => {
  const error = {};
  error.name = 'login';
  error.code = 10901;
  try {
    const sessionUserId = 'user_id';
    logger.debug(`controller.userlogin.login : ${sessionUserId}`);
    const { body } = req;
    const target = {};
    Object.assign(target, body);
    target.pwd = null;
    target.password = null;
    target.passwordConfirm = null;
    createLog(req, ['login', 'userlogin', JSON.stringify(target)]);
    if (!validate.isEmail(body.email)) {
      logger.error('Validation failed [email]');
      return Response.error(res, { code: 10901, message: 'Validation failed' }, 412);
    }
    if (!validate.isLocation(body.srcloc)) {
      logger.error('Validation failed [srcloc]');
      return Response.error(res, { code: 10901, message: 'Validation failed' }, 412);
    }

    const [err, vResult] = await util.to(loginService.loginUserApex(body, req, res));
    
    if (err) {
      error.code = err.code;
      error.message = err.message;
      logger.error(error);
      return Response.error(res, error, 500);
    }
    

    return Response.ok(res, vResult);
  } catch (e) {
    error.message = e.message;
    logger.error(error);
    return Response.error(res, error, 500);
  }
};

/**
 * login userlogin
 *
 * @param   {Object} req
 * @param   {Object} res
 * @returns {Object}
 */
export const loginAuth0 = async (req, res) => {
  const error = {};
  error.name = 'login';
  error.code = 10901;
  try {
    logger.debug(`controller.userlogin.loginAuth0 : ${JSON.stringify(req.query)}`);
    const {code} = req.query
    if (!code) {
      return Response.redirect(res, config.get('serverConfig.web'));
    }
    
    const [err, userAuth0] = await util.to(loginService.getUserByCodeAuth0(code, req, res));
    
    if (err) {
      error.code = err.code;
      error.message = err.message;
      logger.error(error);
      return Response.error(res, error, 500);
    }
    
    userAuth0.srcloc = 'W'
    
    const target = {};
    Object.assign(target, userAuth0);
    createLog(req, ['login', 'userlogin', JSON.stringify(target)]);

    const [err1, vResult1] = await util.to(loginService.loginUserAuth0(userAuth0, req, res));
    
    if (err1) {
      error.code = err.code;
      error.message = err.message;
      logger.error(error);
      return Response.error(res, error, 500);
    }
    
    if (util.isEmpty(vResult1.companyName) && vResult1.userType === 15010) {
      return Response.redirect(res, `https://${req.headers.host}/account/create?invited=true&manager=true`);
    }
    
    const lang = vResult1.basicLanguage === 'en' || vResult1.userType === '15000' ? '' : `/${vResult1.basicLanguage}`
    
    return Response.redirect(res, `https://${req.headers.host}${lang}${USER_TYPE_NAV_MAPPER[vResult1.userType].path}`);
  } catch (e) {
    error.message = e.message;
    logger.error(error);
    return Response.error(res, error, 500);
  }
};
/**
 * refresh userlogin
 *
 * @param   {Object} req
 * @param   {Object} res
 * @returns {Object}
 */
export const refresh = async (req, res) => {
  const sessionUserId = req.session.user ? req.session.user.userId : 'unknown';
  logger.debug(`controller.userlogin.refresh : ${req.hostname}, ${req.clientIp}, ${sessionUserId}`);

  await confirmRefreshToken(req, res);
  
  return 0;
};

/**
 * logout userlogin
 *
 * @param   {Object} req
 * @param   {Object} res
 * @returns {Object}
 */
export const logout = async (req, res) => {
  const error = {};
  error.name = 'logout';
  error.code = 10901;
  try {
    const { user } = req.session;
    if (user) {
      const sessionUserId = user.userId;
      logger.debug(`controller.userlogin.logout : ${sessionUserId}`);
      user.deleteMe = req.body.deleteMe;
      createLog(req, ['logout', 'userlogin', JSON.stringify(user)]);

      // req.logout();
      const deleteMe = (req.body.deleteMe !== undefined && req.body.deleteMe !== null) ? req.body.deleteMe : true;
      if (deleteMe) {
        util.deleteCookie(req, res, 'auth.remember-me', '');
        await util.to(loginService.logoutUser(user));
      } else {
        await util.to(loginService.logoutUserDeleteMe(user));
      }

      // req.logout();
      req.session.destroy((err) => {
        if (err) {
          const msg = 'Error destroying session';
          return Response.ok(res, {
            user: { status: 'logout', msg },
          });
        }
        return Response.ok(res, {
          user: { status: 'logout', msg: 'Please Log in again' },
        });
      });
    } else {
      const cookies = config.get('serverConfig.mode') !== 'test' ? req.signedCookies : req.cookies;
      let token = null;
      if (req && cookies) {
        token = cookies['auth.remember-me'];
      }
      if (token) {
        const decoded = ejwt.verify(config.get('jwt.secretkey'), token, config.get('jwt.encryption'));
        util.deleteCookie(req, res, 'auth.remember-me', '');
        await util.to(loginService.logoutUser(decoded));
      }
      return res.status(401).send('Access denied.');
    }

    // console.log('res ref', res.getHeaders()['set-cookie']);
    // return Response.ok(res, {
    //   user: { status: 'logout', msg: 'Please Log out again' },
    // });
    return null;
  } catch (e) {
    error.message = e.message;
    logger.error(error);
    return Response.error(res, error, 401);
  }
};