Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.web.util;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

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

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

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

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

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.File;

import java.nio.file.Files;

import java.util.Map;

@Component

public class ResponseSender<T> {

	@Autowired

	ObjectMapper objectMapper;

	public ResponseEntity<?> ok(Object response){

		return this.genericError(response, HttpStatus.OK, ResponseStatus.SUCCESS);

	}

	public ResponseEntity<?> okJson(Object response) throws JsonProcessingException {

		String jsonString = objectMapper.writeValueAsString(response);

		Map<String, Object> actualJson = objectMapper.readValue(jsonString, Map.class);

		return this.genericSuccess(actualJson);

	}

	public ResponseEntity<?> badRequest(Object response){

		return this.genericError(response, HttpStatus.BAD_REQUEST, ResponseStatus.FAILURE);

	}

	public ResponseEntity<?> unauthorized(Object response){

		return this.genericError(response, HttpStatus.UNAUTHORIZED, ResponseStatus.FAILURE);

	}

	public ResponseEntity<?> forbidden(Object response){

		return this.genericError(response, HttpStatus.FORBIDDEN, ResponseStatus.FAILURE);

	}

	public ResponseEntity<?> notFound(Object response){

		return this.genericError(response, HttpStatus.NOT_FOUND, ResponseStatus.FAILURE);

	}

	public ResponseEntity<?> internalServerError(Object response){

		return this.genericError(response, HttpStatus.INTERNAL_SERVER_ERROR, ResponseStatus.FAILURE);

	}

	public ResponseEntity<?> badRequest(ProfitMandiBusinessException profitMandiBusinessException){

		return this.genericError(profitMandiBusinessException, HttpStatus.BAD_REQUEST);

	}

	public ResponseEntity<?> unauthorized(ProfitMandiBusinessException profitMandiBusinessException){

		return this.genericError(profitMandiBusinessException, HttpStatus.UNAUTHORIZED);

	}

	public ResponseEntity<?> forbidden(ProfitMandiBusinessException profitMandiBusinessException){

		return this.genericError(profitMandiBusinessException, HttpStatus.FORBIDDEN);

	}

	public ResponseEntity<?> notFound(ProfitMandiBusinessException profitMandiBusinessException){

		return this.genericError(profitMandiBusinessException, HttpStatus.NOT_FOUND);

	}

	public ResponseEntity<?> internalServerError(Throwable exception){

		final Response response=new Response("", "", "GE_1007", exception.getMessage());

		return this.genericError(response, HttpStatus.INTERNAL_SERVER_ERROR);

	}

	private ResponseEntity<?> genericError(ProfitMandiBusinessException profitMandiBusinessException, HttpStatus status){

		final Response response=new Response(profitMandiBusinessException.getRejectedType(), profitMandiBusinessException.getRejectedValue(),profitMandiBusinessException.getCode(), profitMandiBusinessException.getMessage());

		return this.genericError(response, status);

	}

	private ResponseEntity<?> genericError(Response response, HttpStatus status){

		final ProfitMandiResponse<Response> profitMandiResponse=new ProfitMandiResponse<Response>(status.toString(), status, ResponseStatus.FAILURE, response);

		return new ResponseEntity<>(profitMandiResponse, status);

	}

	private ResponseEntity<?> genericError(Object response, HttpStatus status, ResponseStatus responseStatus){

		final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(status.toString(), status, responseStatus, response);

		return new ResponseEntity<>(profitMandiResponse, status);

	}

	private ResponseEntity<?> genericSuccess(Object response) {

		final ProfitMandiResponse<?> profitMandiResponse =

				new ProfitMandiResponse<>(HttpStatus.OK.toString(), HttpStatus.OK, ResponseStatus.SUCCESS, response);

		return ResponseEntity.ok()

				.contentType(MediaType.APPLICATION_JSON)

				.body(profitMandiResponse);

	}

	public void writeBadRequest(HttpServletRequest request, HttpServletResponse response, Response failedResponse) throws Exception{

		this.writeGenericRequest(request, response, failedResponse, HttpStatus.BAD_REQUEST);

	}

	public void writeOk(HttpServletRequest request, HttpServletResponse response, Object data) throws Exception{

		response.setStatus(HttpStatus.OK.value());

		response.setContentType(MediaType.APPLICATION_JSON_VALUE);

		response.setCharacterEncoding("UTF-8");

		response.getWriter().println(data);

		response.getWriter().flush();

	}

	public void writeOkFileContentType(HttpServletRequest request, HttpServletResponse response, File file, String contentType) throws Exception{

		response.setStatus(HttpStatus.OK.value());

		response.setContentType(contentType);

		response.getOutputStream().write(Files.readAllBytes(file.toPath()));

		response.getOutputStream().flush();

	}

	public void writeUnauthorized(HttpServletRequest request, HttpServletResponse response, Response failedResponse) throws Exception{

		this.writeGenericRequest(request, response, failedResponse, HttpStatus.UNAUTHORIZED);

	}

	public void writeForbidden(HttpServletRequest request, HttpServletResponse response, Response failedResponse) throws Exception{

		this.writeGenericRequest(request, response, failedResponse, HttpStatus.FORBIDDEN);

	}

	public void writeNotFound(HttpServletRequest request, HttpServletResponse response, Response failedResponse) throws Exception{

		this.writeGenericRequest(request, response, failedResponse, HttpStatus.NOT_FOUND);

	}

    private void addCorsHeaders(HttpServletRequest request, HttpServletResponse response) {

        String origin = request.getHeader("Origin");

        if (origin != null && !origin.isEmpty()) {

            response.setHeader("Access-Control-Allow-Origin", origin);

            response.setHeader("Access-Control-Allow-Credentials", "true");

            response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE, PUT, PATCH");

            response.setHeader("Access-Control-Allow-Headers",

                    "Content-Type, Auth-Token, Authorization, X-Requested-With, Idempotencykey");

            response.setHeader("Access-Control-Expose-Headers", "Auth-Token, Content-Type, Authorization");

            response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");

            response.setHeader("Pragma", "no-cache");

            response.setHeader("Expires", "0");

        }

    }

    private void writeGenericRequest(HttpServletRequest request, HttpServletResponse response,

                                     Response failedResponse, HttpStatus httpStatus) throws Exception {

        this.addCorsHeaders(request, response);

        response.setStatus(httpStatus.value());

        response.setContentType(MediaType.APPLICATION_JSON_VALUE);

        response.setCharacterEncoding("UTF-8");

        final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(

                httpStatus.toString(), httpStatus, ResponseStatus.FAILURE, failedResponse);

        final Object obj = objectMapper.readValue(objectMapper.writeValueAsString(profitMandiResponse), Object.class);

        final String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);

        response.getWriter().write(jsonString.toString());

        response.getWriter().flush();

    }

}