package com.jasamedika.medifirst2000.controller;

import java.text.ParseException;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.orm.jpa.JpaSystemException;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.jasamedika.medifirst2000.constants.Constants;
import com.jasamedika.medifirst2000.constants.MessageResource;
import com.jasamedika.medifirst2000.controller.base.LocaleController;
import com.jasamedika.medifirst2000.core.web.WebConstants;
import com.jasamedika.medifirst2000.exception.ServiceVOException;
import com.jasamedika.medifirst2000.service.AnggaranRemunerasiService;
import com.jasamedika.medifirst2000.service.BobotJenisIndikatorService;
import com.jasamedika.medifirst2000.service.GradeRemunService;
import com.jasamedika.medifirst2000.service.IkiDanRemunerasiService;
import com.jasamedika.medifirst2000.service.IndeksKinerjaDokterService;
import com.jasamedika.medifirst2000.service.IndikatorKinerjaJabatanService;
import com.jasamedika.medifirst2000.service.IndikatorKinerjaService;
import com.jasamedika.medifirst2000.service.LogbookKinerjaDetailService;
import com.jasamedika.medifirst2000.service.LogbookKinerjaDokterService;
import com.jasamedika.medifirst2000.service.LogbookKinerjaService;
import com.jasamedika.medifirst2000.service.MapPegawaiJabatanToUnitKerjaService;
import com.jasamedika.medifirst2000.service.MapProdukKelompokKerjaService;
import com.jasamedika.medifirst2000.service.PelayananNakesService;
import com.jasamedika.medifirst2000.service.PelayananPasienNakesService;
import com.jasamedika.medifirst2000.service.PelayananPasienPerawatService;
import com.jasamedika.medifirst2000.service.ProdukNakesService;
import com.jasamedika.medifirst2000.service.ProdukPerawatService;
import com.jasamedika.medifirst2000.service.ProfesiService;
import com.jasamedika.medifirst2000.service.RemunerasiOperasionalService;
import com.jasamedika.medifirst2000.service.SkoringTindakanMedisService;
import com.jasamedika.medifirst2000.service.SkoringTindakanNakesService;
import com.jasamedika.medifirst2000.service.SkoringTindakanPerawatService;
import com.jasamedika.medifirst2000.service.TargetSkorDokterService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.rest.RestUtil;
import com.jasamedika.medifirst2000.vo.AnggaranRemunerasiVO;
import com.jasamedika.medifirst2000.vo.BobotJenisIndikatorVO;
import com.jasamedika.medifirst2000.vo.GradeRemunerasiVO;
import com.jasamedika.medifirst2000.vo.IkiDanRemunerasiVO;
import com.jasamedika.medifirst2000.vo.IndeksKinerjaDokterVO;
import com.jasamedika.medifirst2000.vo.IndikatorKinerjaJabatanVO;
import com.jasamedika.medifirst2000.vo.IndikatorKinerjaVO;
import com.jasamedika.medifirst2000.vo.LogbookKinerjaDetailVO;
import com.jasamedika.medifirst2000.vo.LogbookKinerjaDokterVO;
import com.jasamedika.medifirst2000.vo.LogbookKinerjaVO;
import com.jasamedika.medifirst2000.vo.MapProdukKelompokKerjaVO;
import com.jasamedika.medifirst2000.vo.PelayananNakesVO;
import com.jasamedika.medifirst2000.vo.PelayananPasienNakesVO;
import com.jasamedika.medifirst2000.vo.PelayananPasienPerawatVO;
import com.jasamedika.medifirst2000.vo.ProdukNakesVO;
import com.jasamedika.medifirst2000.vo.ProdukPerawatVO;
import com.jasamedika.medifirst2000.vo.ProfesiVO;
import com.jasamedika.medifirst2000.vo.RemunerasiOperasionalVO;
import com.jasamedika.medifirst2000.vo.SettingPirSdmVO;
import com.jasamedika.medifirst2000.vo.SkoringTindakanMedisVO;
import com.jasamedika.medifirst2000.vo.SkoringTindakanNakesVO;
import com.jasamedika.medifirst2000.vo.SkoringTindakanPerawatVO;
import com.jasamedika.medifirst2000.vo.StrukHistoriVO;
import com.jasamedika.medifirst2000.vo.TargetSkorDokterVO;
import com.jasamedika.medifirst2000.vo.custom.CpptDokterVo;
import com.jasamedika.medifirst2000.vo.custom.TargetLayananJamKerjaVO;
import com.jasamedika.medifirst2000.vo.custom.TargetLayananLuarJamKerjaVO;

@RestController
@RequestMapping("/iki-remunerasi")
public class IkiDanRemunerasiController extends LocaleController<IkiDanRemunerasiVO> {

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

	@Autowired
	private IkiDanRemunerasiService service;

	@Autowired
	private GradeRemunService gradeService;

	@Autowired
	private AnggaranRemunerasiService anggaranRemunerasiService;

	@Autowired
	private RemunerasiOperasionalService remunerasiOperasionalService;

	@Autowired
	private IndikatorKinerjaService indikatorKinerjaService;

	@Autowired
	private IndikatorKinerjaJabatanService indikatorKinerjaJabatanService;

	@Autowired
	private SkoringTindakanMedisService skoringTindakanMedisService;

	@Autowired
	private LogbookKinerjaService logbookKinerjaService;

	@Autowired
	private LogbookKinerjaDokterService logbookKinerjaDokterService;

	@Autowired
	private LogbookKinerjaDetailService logbookKinerjaDetailService;

	@Autowired
	private BobotJenisIndikatorService bobotJenisIndikatorService;

	@Autowired
	private MapPegawaiJabatanToUnitKerjaService mapPegawaiJabatanToUnitKerjaService;

	@Autowired
	private SkoringTindakanPerawatService skoringTindakanPerawatService;

	@Autowired
	private PelayananPasienPerawatService pelayananPasienPerawatService;

	@Autowired
	private ProfesiService profesiService;

	@Autowired
	private ProdukPerawatService produkPerawatService;

	@Autowired
	private ProdukNakesService produkNakesService;

	@Autowired
	private SkoringTindakanNakesService skoringTindakanNakesService;

	@Autowired
	private PelayananPasienNakesService pelayananPasienNakesService;

	@Autowired
	private PelayananNakesService pelayananNakesService;

	@Autowired
	private IndeksKinerjaDokterService indeksKinerjaDokterService;

	@Autowired
	private TargetSkorDokterService targetSkorDokterService;

	@Autowired
	private MapProdukKelompokKerjaService mapProdukKelompokKerjaService;

	@RequestMapping(value = "/get-load-data", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> getLoadData(HttpServletRequest request) {
		try {
			Map<String, Object> result = service.loadData();
			if (null != result) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
			} else {
				return RestUtil.getJsonResponse(result, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got exception {} when getLoadData", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when getLoadData", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kalkulasi-remunerasi", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> getKalkulasiDataRemunerasi(
			@RequestParam(value = "id", required = true) Integer id,
			@RequestParam(value = "date", required = true) String date, HttpServletRequest request) {
		try {
			Map<String, Object> result = service.getKalkulasiDataRemunerasi(id, date);
			if (null != result) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
			} else {
				return RestUtil.getJsonResponse(result, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got exception {} when getKalkulasiDataRemunerasi", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when getKalkulasiDataRemunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-iki-remunerasi", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> saveIkiRemunerasi(@Valid @RequestBody StrukHistoriVO vo,
			HttpServletRequest request) {
		try {
			Map<String, Object> result = service.saveIkiRemunerasi(vo);
			if (null != result)
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);

		} catch (ServiceVOException e) {
			LOGGER.error("Got exception {} when saveIkiRemunerasi", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when saveIkiRemunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kalkulasi-remunerasi-pegawai", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> getKalkulasiDataRemunerasiPegawai(
			@RequestParam(value = "date", required = true) String date, HttpServletRequest request) {
		try {
			Map<String, Object> result = service.getKalkulasiDataRemunerasiPegawai(date);
			if (null != result) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
			} else {
				return RestUtil.getJsonResponse(result, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got exception {} when getKalkulasiDataRemunerasi", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when getKalkulasiDataRemunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-pir/{tahun}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> findPir(@PathVariable("tahun") String tahun,
			HttpServletRequest request) {
		Map<String, Object> result = null;
		try {

			result = service.findPir(tahun);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/get-iku/{periode}/{idUnitKerja}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> findPir(@PathVariable("periode") String periode,
			@PathVariable("idUnitKerja") Integer idUnitKerja, HttpServletRequest request) {
		Map<String, Object> result = null;
		try {

			result = service.findIKU(periode, idUnitKerja);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/get-all-iku/", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<Map<String, Object>>> findPir(HttpServletRequest request) {
		List<Map<String, Object>> result = null;
		try {

			result = service.findAllIKU();
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/save-pir-dan-iku", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> savePirDanIku(@Valid @RequestBody List<SettingPirSdmVO> vo,
			HttpServletRequest request) throws ParseException {
		try {
			Map<String, Object> result = service.savePirDanIku(vo);
			if (null != result)
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);

		} catch (ServiceVOException e) {
			LOGGER.error("Got exception {} when add Pegawai Jadwal kerja", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add Pegawai Jadwal kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}

	}

	@RequestMapping(value = "/get-all-target-dan-capaian-layanan-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<TargetLayananJamKerjaVO>> getAllTargetLayananJamKerja(HttpServletRequest request,
			@RequestParam(value = "periode", required = true) String periode,
			@RequestParam(value = "ksmId", required = false) Integer idKsm) throws ParseException {
		try {
			List<TargetLayananJamKerjaVO> result = service.findAllTargetCapaianLayananJamKerja(periode, idKsm);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get all target dan capaian layanan jam kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get all target dan capaian layanan jam kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-all-target-dan-capaian-layanan-luar-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<TargetLayananLuarJamKerjaVO>> getAllTargetLayananLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "periode", required = true) String periode) throws ParseException {
		try {
			List<TargetLayananLuarJamKerjaVO> result = service.findAllTargetCapaianLayananLuarJamKerja(periode);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get all target dan capaian layanan luar jam kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get all target dan capaian layanan luar jam kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-master-grade-remunerasi", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<GradeRemunerasiVO> saveMasterGradeRemunerasi(HttpServletRequest request,
			@Valid @RequestBody GradeRemunerasiVO vo) {
		try {
			GradeRemunerasiVO result = new GradeRemunerasiVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = gradeService.update(vo);
			} else {
				result = gradeService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master grade remunerasi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master grade remunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-anggaran-remunerasi", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<AnggaranRemunerasiVO> saveAnggaranRemunerasi(HttpServletRequest request,
			@Valid @RequestBody AnggaranRemunerasiVO vo) {
		try {
			AnggaranRemunerasiVO result = new AnggaranRemunerasiVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = anggaranRemunerasiService.update(vo);
			} else {
				result = anggaranRemunerasiService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master anggaran remunerasi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master anggaran remunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-remunerasi-operasional", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<RemunerasiOperasionalVO> saveRemunerasiOperasional(HttpServletRequest request,
			@Valid @RequestBody RemunerasiOperasionalVO vo) {
		try {
			RemunerasiOperasionalVO result = new RemunerasiOperasionalVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = remunerasiOperasionalService.update(vo);
			} else {
				result = remunerasiOperasionalService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master remunerasi operasional", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master remunerasi operasional", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-all-anggaran-remunerasi", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveAllAnggaranRemunerasi(HttpServletRequest request,
			@Valid @RequestBody List<AnggaranRemunerasiVO> listVO,
			@RequestParam(value = "loginUserId", required = true) Integer idLoginUser) {
		try {
			List<String> result = anggaranRemunerasiService.addAll(listVO, idLoginUser);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add master all anggaran remunerasi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add master all anggaran remunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-master-indikator-kinerja", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<IndikatorKinerjaVO> saveMasterIndikatorKinerja(HttpServletRequest request,
			@Valid @RequestBody IndikatorKinerjaVO vo) {
		try {
			IndikatorKinerjaVO result = new IndikatorKinerjaVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = indikatorKinerjaService.update(vo);
			} else {
				result = indikatorKinerjaService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master indikator kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master indikator kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-master-indikator-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getMasterIndikatorKinerja(HttpServletRequest request,
			@RequestParam(value = "jenisIndikatorId", required = false) Integer idJenisIndikator,
			@RequestParam(value = "namaIndikator", required = false) String namaIndikator,
			@RequestParam(value = "isStatusVerifikasi", required = false) Boolean statusVerifikasi)
			throws ParseException {
		try {
			List<Map<String, Object>> result = indikatorKinerjaService.findAllIndikatorKinerja(idJenisIndikator,
					namaIndikator, statusVerifikasi);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get master indikator kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get master indikator kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-indikator-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatIndikatorKinerja(HttpServletRequest request,
			@RequestParam(value = "idIndikator", required = false) Integer idIndikator,
			@RequestParam(value = "namaIndikator", required = true) String namaIndikator) throws ParseException {
		try {
			List<Map<String, Object>> result = indikatorKinerjaService.findDuplicateIndikatorKinerja(idIndikator,
					namaIndikator);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat indikator kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat indikator kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-mapping-indikator-jabatan", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<IndikatorKinerjaJabatanVO> saveMappingIndikatorJabatan(HttpServletRequest request,
			@Valid @RequestBody IndikatorKinerjaJabatanVO vo) {
		try {
			IndikatorKinerjaJabatanVO result = new IndikatorKinerjaJabatanVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = indikatorKinerjaJabatanService.update(vo);
			} else {
				result = indikatorKinerjaJabatanService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result) && CommonUtil.isNotNullOrEmpty(result.getResponseMessage())) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, result.getResponseMessage());
				return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
			} else if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update mapping indikator kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update mapping indikator kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-mapping-indikator-all-jabatan", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveMappingIndikatorAllJabatan(HttpServletRequest request,
			@Valid @RequestBody List<IndikatorKinerjaJabatanVO> vo,
			@RequestParam(value = "loginUserId", required = true) Integer idLoginUser) {
		try {
			List<String> result = indikatorKinerjaJabatanService.addAndUpdate(vo, idLoginUser);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add mapping indikator kinerja semua jabatan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add mapping indikator kinerja semua jabatan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-mapping-indikator-jabatan", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getMappingIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan) throws ParseException {
		try {
			Map<String, Object> result = indikatorKinerjaJabatanService.findAllByJabatan(idJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get mapping indikator jabatan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get mapping indikator jabatan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/set-mapping-indikator-jabatan", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> setMappingIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator) throws ParseException {
		try {
			List<Map<String, Object>> result = indikatorKinerjaJabatanService.findAllByIndikator(idIndikator);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when set mapping indikator jabatan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when set mapping indikator jabatan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-indikator-jabatan", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "tglBerlaku", required = true) Long tglBerlaku) throws ParseException {
		try {
			List<Map<String, Object>> result = indikatorKinerjaJabatanService.findDupMap(idIndikator, idJabatan,
					tglBerlaku);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat indikator jabatan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat indikator jabatan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-skoring-tindakan-medis", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanMedisVO> saveSkoringTindakanMedis(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanMedisVO vo) {
		try {
			SkoringTindakanMedisVO result = new SkoringTindakanMedisVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = skoringTindakanMedisService.update(vo);
			} else {
				result = skoringTindakanMedisService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update skor tindakan medis", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update skor tindakan medis", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-all-skoring-tindakan-medis", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getAllSkoringTindakanMedis(HttpServletRequest request,
			@RequestParam(value = "listKelompokKerjaId", required = false) List<Integer> listIdKelompokKerja,
			@RequestParam(value = "namaProduk", required = false) String namaProduk,
			@RequestParam(value = "detailProduk", required = false) String detailProduk,
			@RequestParam(value = "isStatusVerifikasi", required = false) Boolean statusVerifikasi)
			throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanMedisService.findAllEnabled(listIdKelompokKerja,
					namaProduk, detailProduk, statusVerifikasi);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get all skoring tindakan medis", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get all skoring tindakan medis", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-daftar-input-tindakan", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarInputTindakan(HttpServletRequest request,
			@RequestParam(value = "ruanganId", required = true) Integer idRuangan) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanMedisService
					.findDaftarInputTindakanByRuanganKelas(idRuangan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get daftar input tindakan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get daftar input tindakan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-skoring-tindakan-medis", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanMedis(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk", required = true) String namaProduk,
			@RequestParam(value = "kelompokKerjaId", required = true) Integer idKelompokKerja,
			@RequestParam(value = "detailProduk", required = true) String detailProduk,
			@RequestParam(value = "skor", required = true) Double skor,
			@RequestParam(value = "tglBerlaku", required = true) Long tglMulaiBerlaku) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanMedisService.findDuplicateSkoring(namaProduk,
					idKelompokKerja, skor, detailProduk, tglMulaiBerlaku, noRec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan medis", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan medis", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-akses-skoring-tindakan-medis", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanMedis(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			Map<String, Object> result = skoringTindakanMedisService.findAkses(idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get akses skoring tindakan medis", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get akses skoring tindakan medis", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-kontrak-kinerja", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaVO> saveKontrakKinerja(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaVO vo) {
		try {
			LogbookKinerjaVO result = new LogbookKinerjaVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = logbookKinerjaService.update(vo);
			} else {
				result = logbookKinerjaService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result) && CommonUtil.isNotNullOrEmpty(result.getResponseMessage())) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.MESSAGE, result.getResponseMessage());
				return RestUtil.getJsonResponse(result, HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
			} else if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kontrak-kinerja", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			Map<String, Object> result = logbookKinerjaService.findKontrakKinerja(idPegawai, idJabatan, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/cek-kontrak-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> cekKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findKontrakKinerja(idIndikator);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when cek kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when cek kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-pegawai-akses-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getPegawaiAksesKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "listKelompokJabatanId", required = false) List<Integer> listIdKelompokJabatan)
			throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findAksesPegawai(idPegawai, listIdKelompokJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get pegawai akses kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get pegawai akses kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-pengajuan-kontrak-kinerja", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaVO> savePengajuanKontrakKinerja(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaVO vo) {
		try {
			LogbookKinerjaVO result = new LogbookKinerjaVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = logbookKinerjaService.updatePengajuanKontrakKinerja(vo);
			} else {
				result = logbookKinerjaService.addPengajuanKontrakKinerja(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when pengajuan kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when pengajuan kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-daftar-pengajuan-kontrak-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarPengajuanKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findPengajuanKontrakKinerja(idPegawai, idJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get daftar pengajuan kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get daftar pengajuan kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/daftar-indikator-di-unit-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarIndikatorDiUnitKerja(HttpServletRequest request,
			@RequestParam(value = "jenisIndikator", required = true) Integer jenisIndikator,
			@RequestParam(value = "unitKerjaId", required = true) Integer idUnitKerja,
			@RequestParam(value = "levelJabatan", required = true) Integer levelJabatan) throws ParseException {
		try {
			List<Map<String, Object>> result = indikatorKinerjaJabatanService.findIndikatorByUnit(jenisIndikator,
					idUnitKerja, levelJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get daftar indikator di unit kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get daftar indikator di unit kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-kontrak-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDupKontrakKinerja(idPegawai, idJabatan, bulan,
					idIndikator);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat kontrak kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-working-record", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaDetailVO> saveWorkingRecord(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaDetailVO vo) {
		try {
			LogbookKinerjaDetailVO result = new LogbookKinerjaDetailVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = logbookKinerjaDetailService.update(vo);
			} else {
				result = logbookKinerjaDetailService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update working record", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update working record", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-dashboard-kinerja", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getDashboardKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			Map<String, Object> result = logbookKinerjaService.findLogbookKinerja(idPegawai, idJabatan, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get dashboard kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get dashboard kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/widget-dashboard-kinerja", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> widgetDashboardKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			Map<String, Object> result = logbookKinerjaService.findLogbookKinerja(idPegawai, null, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get widget dashboard kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get widget dashboard kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/widget-status-verifikasi-kinerja", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> widgetStatusVerifikasi(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			Map<String, Object> result = logbookKinerjaDetailService.findWidgetStatusVerifikasi(idPegawai, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get widget status verifikasi kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get widget status verifikasi kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/catatan-kegiatan-harian-belum-verif", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianBelumVerif(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaDetailService.findWorkingRecord(idPegawai, idJabatan,
					bulan, false);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian belum verifikasi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian belum verifikasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/catatan-kegiatan-harian-sudah-verif", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianSudahVerif(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaDetailService.findWorkingRecord(idPegawai, idJabatan,
					bulan, true);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian sudah verifikasi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian sudah verifikasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/catatan-kegiatan-harian-indikator", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianByIndikator(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator,
			@RequestParam(value = "bulan", required = true) Long bulan) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaDetailService.findWorkingRecord(idPegawai, idJabatan,
					idIndikator, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian by indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get catatan kegiatan harian by indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-akses-pegawai-verifikasi-kinerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getAksesPegawaiVerifikasiKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaDetailService.findAksesPegawai(idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get akses pegawai verifikasi kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get akses pegawai verifikasi kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-bobot-jenis-indikator", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<BobotJenisIndikatorVO> saveBobotJenisIndikator(HttpServletRequest request,
			@Valid @RequestBody BobotJenisIndikatorVO vo) {
		try {
			BobotJenisIndikatorVO result = new BobotJenisIndikatorVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = bobotJenisIndikatorService.update(vo);
			} else {
				result = bobotJenisIndikatorService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-all-bobot-jenis-indikator", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveAllBobotJenisIndikator(HttpServletRequest request,
			@Valid @RequestBody List<BobotJenisIndikatorVO> vos) {
		try {
			List<String> result = bobotJenisIndikatorService.addAll(vos);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add all bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add all bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/update-all-bobot-jenis-indikator", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> updateAllBobotJenisIndikator(HttpServletRequest request,
			@Valid @RequestBody List<BobotJenisIndikatorVO> vos) {
		try {
			List<String> result = bobotJenisIndikatorService.updateAll(vos);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when update all bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when update all bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-master-bobot-jenis-indikator", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "periode", required = true) Long periode,
			@RequestParam(value = "kelompokKerjaId", required = false) Integer idKelompokKerja) {
		try {
			List<Map<String, Object>> result = bobotJenisIndikatorService.findAllBobotJenis(periode, idKelompokKerja);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get master bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get master bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-edit-master-bobot-jenis-indikator", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getEditMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "tglPembaharuanData", required = true) Long tglPembaharuanData)
			throws ParseException {
		try {
			Map<String, Object> result = bobotJenisIndikatorService.findBobotJenis(tglPembaharuanData);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get edit bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get edit bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-master-bobot-jenis-indikator", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deleteMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String norec) {
		try {
			Boolean result = bobotJenisIndikatorService.delete(norec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete master bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete master bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-all-master-bobot-jenis-indikator", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deleteAllMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "tglPembaharuanData", required = true) Long tglPembaharuanData) {
		try {
			Boolean result = bobotJenisIndikatorService.deleteAll(tglPembaharuanData);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete all master bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete all master bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-bobot-jenis-by-jabatan", method = RequestMethod.GET)
	public ResponseEntity<List<Double>> getBobotJenisIndikatorByJabatan(HttpServletRequest request,
			@RequestParam(value = "periode", required = true) Long periode,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan) throws ParseException {
		try {
			List<Double> result = logbookKinerjaService.findBobotJenisJabatan(periode, idJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get bobot jenis indikator by jabatan", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get bobot jenis indikator by jabatan", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplikat-bobot-jenis-indikator", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "periode", required = true) Long periode,
			@RequestParam(value = "jenisIndikatorId", required = true) Integer idJenisIndikator,
			@RequestParam(value = "kelompokJabatanId", required = false) Integer idKelompokJabatan)
			throws ParseException {
		try {
			List<Map<String, Object>> result = bobotJenisIndikatorService.findBobotJenis(periode, idJenisIndikator,
					idKelompokJabatan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat bobot jenis indikator", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat bobot jenis indikator", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-logbook-skoring-dokter-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringDokterJamKerja(HttpServletRequest request,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findLogbookJamKerjaDokter(idPegawai, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get logbook skoring dokter di jam kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get logbook skoring dokter di jam kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-detail-pasien-dokter-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailPasienDetailJamKerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator,
			@RequestParam(value = "produkId", required = true) Integer idProduk,
			@RequestParam(value = "tglPelayanan", required = true) String tglPelayanan,
			@RequestParam(value = "jenisPetugasId", required = true) Integer idJenisPetugas,
			@RequestParam(value = "skor", required = true) Double skor) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDetailLogbookJamKerjaDokter(idPegawai,
					idIndikator, idProduk, tglPelayanan, idJenisPetugas, skor);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get detail pasien logbook skoring dokter di jam kerja",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get detail pasien logbook skoring dokter di jam kerja",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-logbook-skoring-dokter-luar-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringDokterLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findLogbookLuarJamKerjaDokter(idPegawai, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get logbook skoring dokter di luar jam kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get logbook skoring dokter di luar jam kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-detail-pasien-dokter-luar-jam-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailPasienDetailLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "indikatorId", required = true) Integer idIndikator,
			@RequestParam(value = "produkId", required = true) Integer idProduk,
			@RequestParam(value = "tglPelayanan", required = true) String tglPelayanan,
			@RequestParam(value = "jenisPetugasId", required = true) Integer idJenisPetugas,
			@RequestParam(value = "skor", required = true) Double skor) throws ParseException {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDetailLogbookLuarJamKerjaDokter(idPegawai,
					idIndikator, idProduk, tglPelayanan, idJenisPetugas, skor);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get detail pasien logbook skoring dokter di luar jam kerja",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get detail pasien logbook skoring dokter di luar jam kerja",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-penilaian-kinerja-individu", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getPenilaianKinerjaIndividu(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "jabatanId", required = true) Integer idJabatan,
			@RequestParam(value = "bulan", required = true) Long bulan) {
		try {
			Map<String, Object> result = logbookKinerjaService.findPenilaianKinerja(idPegawai, idJabatan, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get penilaian kinerja individu", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get penilaian kinerja individu", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-rekap-penilaian-kinerja-individu", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getRekapPenilaianKinerjaIndividu(HttpServletRequest request,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "unitKerjaId", required = false) Integer idUnitKerja,
			@RequestParam(value = "subunitKerjaId", required = false) Integer idSubunitKerja,
			@RequestParam(value = "pegawaiId", required = false) Integer idPegawai) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findRekapPenilaianKinerja(bulan, idUnitKerja,
					idSubunitKerja, idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get rekapitulasi penilaian kinerja individu", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get rekapitulasi penilaian kinerja individu", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/verifikasi-logbook-skor", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaVO> verifikasiLogbookSkor(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaVO vo) {
		try {
			LogbookKinerjaVO result = logbookKinerjaService.verify(vo);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.MESSAGE, "Penilaian kinerja tidak ditemukan");
				return RestUtil.getJsonResponse(result, HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when verifikasi logbook dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when verifikasi logbook dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/pegawai-remun-unit-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getPegawaiRemunByUnitKerja(HttpServletRequest request,
			@RequestParam(value = "unitKerjaId", required = false) Integer idUnitKerja,
			@RequestParam(value = "subunitKerjaId", required = false) Integer idSubunitKerja) throws ParseException {
		try {
			List<Map<String, Object>> result = mapPegawaiJabatanToUnitKerjaService.findPegawaiByUnitKerja(idUnitKerja,
					idSubunitKerja);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get akses pegawai verifikasi logbook dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get akses pegawai verifikasi logbook dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-skoring-tindakan-perawat", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanPerawatVO> saveSkoringTindakanPerawat(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanPerawatVO vo) {
		try {
			SkoringTindakanPerawatVO result = new SkoringTindakanPerawatVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = skoringTindakanPerawatService.update(vo);
			} else {
				result = skoringTindakanPerawatService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update skor tindakan oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update skor tindakan oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-all-skoring-tindakan-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getAllSkoringTindakanPerawat(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = false) String namaProduk,
			@RequestParam(value = "isVerif", required = false) Boolean isVerif,
			@RequestParam(value = "kdKlasif", required = false) Short kdKlasif) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanPerawatService.findAllEnabled(namaProduk, isVerif,
					kdKlasif);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get all skoring tindakan oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get all skoring tindakan oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-skoring-tindakan-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk", required = true) String namaProduk,
			@RequestParam(value = "skor", required = true) Double skor,
			@RequestParam(value = "tglBerlaku", required = true) Long tglMulaiBerlaku) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanPerawatService.findDuplicateSkoring(namaProduk, skor,
					tglMulaiBerlaku, noRec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-akses-skoring-tindakan-perawat", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanPerawat(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			Map<String, Object> result = skoringTindakanPerawatService.findAkses(idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get akses skoring tindakan oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get akses skoring tindakan oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-pelayanan-pasien-perawat", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananPasienPerawatVO> savePelayananPasienPerawat(HttpServletRequest request,
			@Valid @RequestBody PelayananPasienPerawatVO vo) {
		try {
			PelayananPasienPerawatVO result = new PelayananPasienPerawatVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = pelayananPasienPerawatService.update(vo);
			} else {
				result = pelayananPasienPerawatService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update pelayanan pasien oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update pelayanan pasien oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-pelayanan-pasien-perawat", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deletePelayananPasienPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String norec) {
		try {
			Boolean result = pelayananPasienPerawatService.delete(norec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete pelayanan pasien oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete pelayanan pasien oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-pelayanan-pasien-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getPelayananPasienPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String noRec,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			List<Map<String, Object>> result = pelayananPasienPerawatService.findByAntrianPasienDiperiksa(noRec,
					idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get pelayanan pasien oleh perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get pelayanan pasien oleh perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-produk-perawat", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<ProdukPerawatVO> saveProdukPerawat(HttpServletRequest request,
			@Valid @RequestBody ProdukPerawatVO vo) {
		try {
			ProdukPerawatVO result = new ProdukPerawatVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = produkPerawatService.update(vo);
			} else {
				result = produkPerawatService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master produk perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master produk perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-produk-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getProdukPerawat(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = false) String namaProduk,
			@RequestParam(value = "kdKlasif", required = false) Short kdKlasif) {
		try {
			List<Map<String, Object>> result = produkPerawatService.findAllActive(namaProduk, kdKlasif);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get master produk perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get master produk perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-produk-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatProdukPerawat(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = true) String namaProduk,
			@RequestParam(value = "kdKlasif", required = true) Short kdKlasif,
			@RequestParam(value = "produkId", required = false) Integer idProduk) {
		try {
			List<Map<String, Object>> result = produkPerawatService.findDupProdukPerawat(namaProduk, kdKlasif,
					idProduk);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat produk perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat produk perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-profesi-nakes", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<ProfesiVO> saveProfesiNakes(HttpServletRequest request, @Valid @RequestBody ProfesiVO vo) {
		try {
			ProfesiVO result = new ProfesiVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = profesiService.update(vo);
			} else {
				result = profesiService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master profesi nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master profesi nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-profesi-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<ProfesiVO>> getProfesiNakes(HttpServletRequest request) {
		try {
			List<ProfesiVO> result = profesiService.findAllActive();
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get master profesi nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get master profesi nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-produk-nakes", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<ProdukNakesVO> saveProdukNakes(HttpServletRequest request,
			@Valid @RequestBody ProdukNakesVO vo) {
		try {
			ProdukNakesVO result = new ProdukNakesVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = produkNakesService.update(vo);
			} else {
				result = produkNakesService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update master produk nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update master produk nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-produk-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getProdukNakes(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = false) String namaProduk,
			@RequestParam(value = "kdProduk", required = false) Short kdProduk,
			@RequestParam(value = "profesiId", required = false) Integer idProfesi) {
		try {
			List<Map<String, Object>> result = produkNakesService.findProdukNakes(namaProduk, kdProduk, idProfesi);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get master produk nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get master produk nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-produk-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatProdukNakes(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = true) String namaProduk,
			@RequestParam(value = "profesiId", required = true) Integer idProfesi,
			@RequestParam(value = "produkId", required = false) Integer idProduk) {
		try {
			List<Map<String, Object>> result = produkNakesService.findDupProdukNakes(namaProduk, idProfesi, idProduk);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat produk nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat produk nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-skoring-tindakan-nakes", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanNakesVO> saveSkoringTindakanNakes(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanNakesVO vo) {
		try {
			SkoringTindakanNakesVO result = new SkoringTindakanNakesVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = skoringTindakanNakesService.update(vo);
			} else {
				result = skoringTindakanNakesService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update skor tindakan oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update skor tindakan oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-all-skoring-tindakan-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getAllSkoringTindakanNakes(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = false) String namaProduk,
			@RequestParam(value = "isVerif", required = false) Boolean isVerif,
			@RequestParam(value = "profesiId", required = false) Integer idProfesi) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanNakesService.findAllEnabled(namaProduk, isVerif,
					idProfesi);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get all skoring tindakan oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get all skoring tindakan oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-duplicate-skoring-tindakan-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanNakes(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk", required = true) String namaProduk,
			@RequestParam(value = "profesiId", required = true) Integer idProfesi,
			@RequestParam(value = "skor", required = true) Double skor,
			@RequestParam(value = "tglBerlaku", required = true) Long tglMulaiBerlaku) throws ParseException {
		try {
			List<Map<String, Object>> result = skoringTindakanNakesService.findDuplicateSkoring(namaProduk, skor,
					idProfesi, tglMulaiBerlaku, noRec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get duplikat skoring tindakan oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-akses-skoring-tindakan-nakes", method = RequestMethod.GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanNakes(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			Map<String, Object> result = skoringTindakanNakesService.findAkses(idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get akses skoring tindakan oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get akses skoring tindakan oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-pelayanan-pasien-nakes", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananPasienNakesVO> savePelayananPasienNakes(HttpServletRequest request,
			@Valid @RequestBody PelayananPasienNakesVO vo) {
		try {
			PelayananPasienNakesVO result = new PelayananPasienNakesVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = pelayananPasienNakesService.update(vo);
			} else {
				result = pelayananPasienNakesService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update pelayanan pasien oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update pelayanan pasien oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-pelayanan-pasien-nakes", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deletePelayananPasienNakes(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String norec) {
		try {
			Boolean result = pelayananPasienNakesService.delete(norec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete pelayanan pasien oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete pelayanan pasien oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-pelayanan-pasien-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getPelayananPasienNakes(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String noRec,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) throws ParseException {
		try {
			List<Map<String, Object>> result = pelayananPasienNakesService.findByAntrianPasienDiperiksa(noRec,
					idPegawai);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get pelayanan pasien oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get pelayanan pasien oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-pelayanan-nakes", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananNakesVO> savePelayananNakes(HttpServletRequest request,
			@Valid @RequestBody PelayananNakesVO vo) {
		try {
			PelayananNakesVO result = new PelayananNakesVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = pelayananNakesService.update(vo);
			} else {
				result = pelayananNakesService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_ERROR,
						getMessage(MessageResource.LABEL_ERROR, request));
				return RestUtil.getJsonHttptatus(HttpStatus.BAD_REQUEST, mapHeaderMessage);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update pelayanan nonpasien oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update pelayanan nonpasien oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-pelayanan-nakes", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deletePelayananNakes(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String norec) {
		try {
			Boolean result = pelayananNakesService.delete(norec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete pelayanan nonpasien oleh nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete pelayanan nonpasien oleh nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-all-indeks-kinerja-dokter", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveAllIndeksKinerjaDokter(HttpServletRequest request,
			@Valid @RequestBody List<IndeksKinerjaDokterVO> vos) {
		try {
			List<String> result = indeksKinerjaDokterService.addAll(vos);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add all indeks kinerja dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add all indeks kinerja dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/verifikasi-presensi-dpjp", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaDokterVO> verifikasiPresensiDpjp(HttpServletRequest request,
			@Valid @RequestBody CpptDokterVo vo) {
		try {
			LogbookKinerjaDokterVO result = logbookKinerjaDokterService.verify(vo);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NO_CONTENT);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when verifikasi logbook dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when verifikasi logbook dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-target-skor-dokter", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<TargetSkorDokterVO> saveTargetSkorDokter(HttpServletRequest request,
			@Valid @RequestBody TargetSkorDokterVO vo) {
		try {
			TargetSkorDokterVO result = new TargetSkorDokterVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = targetSkorDokterService.update(vo);
			} else {
				result = targetSkorDokterService.add(vo);
			}
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NO_CONTENT);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update target skor dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update target skor dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-target-skor-kelompok-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getTargetSkorKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "tahun", required = true) Long tahun) throws ParseException {
		try {
			List<Map<String, Object>> result = targetSkorDokterService.findAll(tahun);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get target skor kelompok kerja dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get target skor kelompok kerja dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-logbook-skoring-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringNakes(HttpServletRequest request,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findLogbookNakes(idPegawai, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get logbook skoring nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get logbook skoring nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-detail-logbook-skoring-nakes", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookSkoringNakes(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "produkId", required = true) Integer idProduk,
			@RequestParam(value = "tglPelayanan", required = true) String tglPelayanan) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDetailLogbookNakes(idPegawai, idProduk,
					tglPelayanan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get detail logbook skoring nakes lain", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get detail logbook skoring nakes lain", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-tindakan-belum-ada-skor", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getTindakanBelumAdaSkor(HttpServletRequest request,
			@RequestParam(value = "listKelompokKerjaId", required = false) List<Integer> listIdKelompokKerja) {
		try {
			List<Map<String, Object>> result = skoringTindakanMedisService
					.findTindakanBelumAdaSkor(listIdKelompokKerja);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get tindakan belum ada skor", sve.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get tindakan belum ada skor", jse.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-deskripsi-tindakan-skor-medis", method = RequestMethod.GET)
	public ResponseEntity<Map<String, String>> getDeskripsiTindakanSkorMedis(HttpServletRequest request,
			@RequestParam(value = "produkId", required = true) Integer idProduk,
			@RequestParam(value = "kelompokKerjaId", required = true) Integer idKelompokKerja) {
		try {
			Map<String, String> result = skoringTindakanMedisService.findDeskripsiSkoringTindakanMedis(idProduk,
					idKelompokKerja);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get deskripsi tindakan skor medis", sve.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get deskripsi tindakan skor medis", jse.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-daftar-tindakan-logbook-skor", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarTindakanLogbookSkor(HttpServletRequest request,
			@RequestParam(value = "namaProduk", required = false) String namaProduk) {
		try {
			List<Map<String, Object>> result = skoringTindakanMedisService.findTindakanLogbookSkor(namaProduk);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get tindakan logbook skor", sve.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get tindakan logbook skor", jse.getMessage());
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-logbook-skoring-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringPerawat(HttpServletRequest request,
			@RequestParam(value = "bulan", required = true) Long bulan,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findLogbookPerawat(idPegawai, bulan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get logbook skoring perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get logbook skoring perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-detail-logbook-skoring-perawat", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookSkoringPerawat(HttpServletRequest request,
			@RequestParam(value = "pegawaiId", required = true) Integer idPegawai,
			@RequestParam(value = "produkId", required = true) Integer idProduk,
			@RequestParam(value = "tglPelayanan", required = true) String tglPelayanan) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDetailLogbookPerawat(idPegawai, idProduk,
					tglPelayanan);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get detail logbook skoring perawat", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get detail logbook skoring perawat", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-all-map-produk-kelompok-kerja", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveAllMapProdukKelompokKerja(HttpServletRequest request,
			@Valid @RequestBody List<MapProdukKelompokKerjaVO> vos) {
		try {
			List<String> result = mapProdukKelompokKerjaService.addAll(vos);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add all mapping produk - kelompok kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add all mapping produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-map-produk-kelompok-kerja", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<MapProdukKelompokKerjaVO> saveMapProdukKelompokKerja(HttpServletRequest request,
			@Valid @RequestBody MapProdukKelompokKerjaVO vo) {
		try {
			MapProdukKelompokKerjaVO result = new MapProdukKelompokKerjaVO();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = mapProdukKelompokKerjaService.update(vo);
			} else {
				result = mapProdukKelompokKerjaService.add(vo);
			}

			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
						getMessage(MessageResource.LABEL_SUCCESS, request));
				return RestUtil.getJsonResponse(result, HttpStatus.CREATED, mapHeaderMessage);
			} else {
				return RestUtil.getJsonHttptatus(HttpStatus.NOT_ACCEPTABLE);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when add/update mapping produk - kelompok kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when add/update mapping produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-map-produk-kelompok-kerja", method = RequestMethod.POST)
	public ResponseEntity<Boolean> deleteMapProdukKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "noRec", required = true) String norec) {
		try {
			Boolean result = mapProdukKelompokKerjaService.delete(norec);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when delete mapping produk - kelompok kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when delete mapping produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-subject-map-produk-kelompok-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getSubjectMapProdukKelompokKerja(HttpServletRequest request) {
		try {
			List<Map<String, Object>> result = mapProdukKelompokKerjaService.getAllProduk();
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get subject map produk - kelompok kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get subject map produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-object-map-produk-kelompok-kerja", method = RequestMethod.GET)
	public ResponseEntity<List<Map<String, Object>>> getObjectMapProdukKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "produkId", required = true) Integer idProduk) {
		try {
			List<Map<String, Object>> result = mapProdukKelompokKerjaService.getAllKelompokKerja(idProduk);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got exception {} when get object map produk - kelompok kerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got exception {} when get object map produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

}