Subversion Repositories SmartDukaan

package com.spice.profitmandi.admin.util;

import java.io.UnsupportedEncodingException;

import java.time.Instant;

import java.util.Arrays;

import java.util.Date;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.auth0.jwt.JWT;

import com.auth0.jwt.JWTCreator.Builder;

import com.auth0.jwt.JWTVerifier;

import com.auth0.jwt.algorithms.Algorithm;

import com.auth0.jwt.exceptions.InvalidClaimException;

import com.auth0.jwt.exceptions.JWTCreationException;

import com.auth0.jwt.exceptions.JWTDecodeException;

import com.auth0.jwt.interfaces.Claim;

import com.auth0.jwt.interfaces.DecodedJWT;

import com.spice.profitmandi.common.ResponseCodeHolder;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.model.UserInfo;

public class JWTUtil {

	private static final String SECRET_KEY = "profitmandi-admin";

	private static final String USER_ID = "userId";

	private static final String EMAIL = "email";

	private static final String ROLE_NAMES = "roleNames";

	private static final String PROFIT_MANDI = "profitmandi";

	// 60 days

	private static final int EXPIRE_TIME_IN_SECONDS = ((60 * 60) * 24) * 60;

	private static Algorithm ALGORITHM;

	private static final Logger LOGGER = LoggerFactory.getLogger(JWTUtil.class);

	static {

		try {

			ALGORITHM = Algorithm.HMAC256(SECRET_KEY);

		} catch (IllegalArgumentException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (UnsupportedEncodingException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public static String create(long userId, String[] roleNames) {

		try {

			return createBuilder().withClaim(USER_ID, (int) userId).withArrayClaim(ROLE_NAMES, roleNames)

					.sign(ALGORITHM);

		} catch (JWTCreationException jwtCreationException) {

			throw new RuntimeException(ResponseCodeHolder.getMessage("USR_1011"));

		}

	}

	public static String create(String email) {

		try {

			return createBuilder().withClaim(EMAIL, email).sign(ALGORITHM);

		} catch (JWTCreationException jwtCreationException) {

			throw new RuntimeException(ResponseCodeHolder.getMessage("USR_1011"));

		}

	}

	public static String create(String email, String[] roleNames) {

		try {

			return createBuilder().withClaim(EMAIL, email).withArrayClaim(ROLE_NAMES, roleNames).sign(ALGORITHM);

		} catch (JWTCreationException jwtCreationException) {

			throw new RuntimeException(ResponseCodeHolder.getMessage("USR_1011"));

		}

	}

	private static Builder createBuilder() {

		Instant createTimestamp = Instant.now();

		Instant expireTimestamp = Instant.now().plusSeconds(EXPIRE_TIME_IN_SECONDS);

		// LOGGER.info("Creating token with issuer {}, issuedAt {}, expireAt

		// {}", PROFIT_MANDI, createTimestamp.toString(),

		// expireTimestamp.toString());

		return JWT.create().withIssuer(PROFIT_MANDI).withIssuedAt(Date.from(createTimestamp))

				.withExpiresAt(Date.from(expireTimestamp));

	}

	public static boolean isExpired(String token) throws ProfitMandiBusinessException {

		DecodedJWT decodedJWT = parse(token);

		Instant expireTime = decodedJWT.getExpiresAt().toInstant();

		Instant currentTime = Instant.now();

		// LOGGER.info("Checking token Expire time of token {} with currentTime

		// {}, expireTime {}", token, currentTime, expireTime);

		if (currentTime.toEpochMilli() > expireTime.toEpochMilli()) {

			return true;

		} else {

			return false;

		}

	}

	public static List<String> getRoleNames(String token) throws ProfitMandiBusinessException {

		DecodedJWT decodedJWT = parse(token);

		Map<String, Claim> claims = decodedJWT.getClaims();

		if (claims.containsKey(ROLE_NAMES)) {

			Claim claim = claims.get(ROLE_NAMES);

			return Arrays.asList(claim.asArray(String.class));

		} else {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.TOKEN, token, "USR_1009");

		}

	}

	private static DecodedJWT parse(String token) throws ProfitMandiBusinessException {

		try {

			JWTVerifier verifier = JWT.require(ALGORITHM).withIssuer(PROFIT_MANDI).build(); // Reusable

																							// verifier

																							// instance

			return verifier.verify(token);

		} catch (JWTDecodeException exception) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.TOKEN, token, "USR_1010");

		} catch (InvalidClaimException invalidClaimException) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.TOKEN, token, "USR_1012");

		}

	}

	public static UserInfo getUserInfo(String token) throws ProfitMandiBusinessException {

		DecodedJWT decodedJWT = parse(token);

		Instant expireTime = decodedJWT.getExpiresAt().toInstant();

		Instant currentTime = Instant.now();

		if (currentTime.toEpochMilli() > expireTime.toEpochMilli()) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.TOKEN, token, "USR_1012");

		}

		Map<String, Claim> claims = decodedJWT.getClaims();

		if (claims.containsKey(USER_ID)) {

			final Claim userIdclaim = claims.get(USER_ID);

			int userId = userIdclaim.asInt();

			final Claim roleNamesClaim = claims.get(ROLE_NAMES);

			final UserInfo userInfo = new UserInfo(userId, Arrays.asList(roleNamesClaim.asArray(String.class)), null);

			return userInfo;

		} else if (claims.containsKey(EMAIL)) {

			final Claim emailClaim = claims.get("email");

			final UserInfo userInfo = new UserInfo(-1, null, emailClaim.asString());

			return userInfo;

		} else {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.TOKEN, token, "USR_1008");

		}

	}

}