SC-be-java/jasamedika-sdm/src/main/java/com/jasamedika/medifirst2000/controller/IkiDanRemunerasiController.java

package com.jasamedika.medifirst2000.controller;

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.dto.LogbookKinerjaDetailLogDto;
import com.jasamedika.medifirst2000.exception.ServiceVOException;
import com.jasamedika.medifirst2000.service.*;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.rest.RestUtil;
import com.jasamedika.medifirst2000.vo.*;
import com.jasamedika.medifirst2000.vo.custom.CpptDokterVo;
import com.jasamedika.medifirst2000.vo.custom.TargetLayananJamKerjaVO;
import com.jasamedika.medifirst2000.vo.custom.TargetLayananLuarJamKerjaVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.orm.jpa.JpaSystemException;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.text.ParseException;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Map;

import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
import static org.springframework.web.bind.annotation.RequestMethod.GET;
import static org.springframework.web.bind.annotation.RequestMethod.POST;

@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 PelayananPasienService pelayananPasienService;

	@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;

	@Autowired
	private ProdukFarmakologiService produkFarmakologiService;

	@Autowired
	private SkoringTindakanFarmakologiService skoringTindakanFarmakologiService;

	@Autowired
	private PelayananFarmakologiService pelayananFarmakologiService;

	@Autowired
	private PenilaianKinerjaService penilaianKinerjaService;

	@Autowired
	private RemunerasiService remunerasiService;

	@Autowired
	private LogbookKinerjaDetailLogService logbookLogService;

	@RequestMapping(value = "/get-load-data", method = GET, produces = 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(null, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got ServiceVOException {} 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 JpaSystemException {} when getLoadData", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kalkulasi-remunerasi", method = GET, produces = APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> getKalkulasiDataRemunerasi(@RequestParam(value = "id") Integer id,
			@RequestParam(value = "date") 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(null, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got ServiceVOException {} 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 JpaSystemException {} when getKalkulasiDataRemunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-iki-remunerasi", method = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} when saveIkiRemunerasi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kalkulasi-remunerasi-pegawai", method = GET, produces = APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> getKalkulasiDataRemunerasiPegawai(
			@RequestParam(value = "date") 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(null, HttpStatus.NOT_FOUND, mapHeaderMessage);
			}
		} catch (ServiceVOException e) {
			LOGGER.error("Got ServiceVOException {} when getKalkulasiDataRemunerasiPegawai", e.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, e.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when getKalkulasiDataRemunerasiPegawai", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-pir/{tahun}", method = GET, produces = 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) {
			System.out.println(e.getMessage());
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/get-iku/{periode}/{idUnitKerja}", method = GET, produces = 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) {
			System.out.println(e.getMessage());
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/get-all-iku/", method = GET, produces = 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) {
			System.out.println(e.getMessage());
		}
		return RestUtil.getJsonResponse(result, HttpStatus.OK);
	}

	@RequestMapping(value = "/save-pir-dan-iku", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<Map<String, Object>> savePirDanIku(@Valid @RequestBody List<SettingPirSdmVO> vo,
			HttpServletRequest request) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<TargetLayananJamKerjaVO>> getAllTargetLayananJamKerja(HttpServletRequest request,
			@RequestParam(value = "periode") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<TargetLayananLuarJamKerjaVO>> getAllTargetLayananLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "periode") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<GradeRemunerasiVO> saveMasterGradeRemunerasi(HttpServletRequest request,
			@Valid @RequestBody GradeRemunerasiVO vo) {
		try {
			GradeRemunerasiVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<AnggaranRemunerasiVO> saveAnggaranRemunerasi(HttpServletRequest request,
			@Valid @RequestBody AnggaranRemunerasiVO vo) {
		try {
			AnggaranRemunerasiVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<RemunerasiOperasionalVO> saveRemunerasiOperasional(HttpServletRequest request,
			@Valid @RequestBody RemunerasiOperasionalVO vo) {
		try {
			RemunerasiOperasionalVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveAllAnggaranRemunerasi(HttpServletRequest request,
			@Valid @RequestBody List<AnggaranRemunerasiVO> listVO,
			@RequestParam(value = "loginUserId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<IndikatorKinerjaVO> saveMasterIndikatorKinerja(HttpServletRequest request,
			@Valid @RequestBody IndikatorKinerjaVO vo) {
		try {
			IndikatorKinerjaVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatIndikatorKinerja(HttpServletRequest request,
			@RequestParam(value = "idIndikator", required = false) Integer idIndikator,
			@RequestParam(value = "namaIndikator") String namaIndikator) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<IndikatorKinerjaJabatanVO> saveMappingIndikatorJabatan(HttpServletRequest request,
			@Valid @RequestBody IndikatorKinerjaJabatanVO vo) {
		try {
			IndikatorKinerjaJabatanVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<List<String>> saveMappingIndikatorAllJabatan(HttpServletRequest request,
			@Valid @RequestBody List<IndikatorKinerjaJabatanVO> vo,
			@RequestParam(value = "loginUserId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getMappingIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "jabatanId") Integer idJabatan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> setMappingIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "indikatorId") Integer idIndikator) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatIndikatorJabatan(HttpServletRequest request,
			@RequestParam(value = "indikatorId") Integer idIndikator,
			@RequestParam(value = "jabatanId") Integer idJabatan, @RequestParam(value = "tglBerlaku") Long tglBerlaku) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanMedisVO> saveSkoringTindakanMedis(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanMedisVO vo) {
		try {
			SkoringTindakanMedisVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarInputTindakan(HttpServletRequest request,
			@RequestParam(value = "ruanganId") Integer idRuangan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanMedis(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk") String namaProduk,
			@RequestParam(value = "kelompokKerjaId") Integer idKelompokKerja,
			@RequestParam(value = "detailProduk") String detailProduk, @RequestParam(value = "skor") Double skor,
			@RequestParam(value = "tglBerlaku") Long tglMulaiBerlaku) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanMedis(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaVO> saveKontrakKinerja(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaVO vo) {
		try {
			LogbookKinerjaVO result;
			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 ServiceVOException {} 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 JpaSystemException {} when add/update kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/set-kontrak-kinerja", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<Boolean> setKontrakKinerja(HttpServletRequest request, @RequestBody Long bulan) {
		try {
			logbookKinerjaService.autoVerifKontrakJamKerjaDokter(new Date(bulan));
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(true, HttpStatus.CREATED, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when add/update set 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 JpaSystemException {} when add/update set kontrak kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-kontrak-kinerja", method = GET)
	public ResponseEntity<Map<String, Object>> getKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> cekKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "indikatorId") Integer idIndikator) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getPegawaiAksesKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai,
			@RequestParam(value = "listKelompokJabatanId", required = false) List<Integer> listIdKelompokJabatan) {
		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 ServiceVOException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaVO> savePengajuanKontrakKinerja(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaVO vo) {
		try {
			LogbookKinerjaVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarPengajuanKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai,
			@RequestParam(value = "jabatanId") Integer idJabatan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDaftarIndikatorDiUnitKerja(HttpServletRequest request,
			@RequestParam(value = "jenisIndikator") Integer jenisIndikator,
			@RequestParam(value = "unitKerjaId") Integer idUnitKerja,
			@RequestParam(value = "levelJabatan") Integer levelJabatan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatKontrakKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "indikatorId") Integer idIndikator) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<LogbookKinerjaDetailVO> saveWorkingRecord(HttpServletRequest request,
			@Valid @RequestBody LogbookKinerjaDetailVO vo) {
		try {
			LogbookKinerjaDetailVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getDashboardKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> widgetDashboardKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> widgetStatusVerifikasi(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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-tanpa-status-verif", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianAllTanpaStatusVerif(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan) {
		try {
			List<Map<String, Object>> result = logbookKinerjaDetailService.findWorkingRecordTanpaStatusVerif(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 ServiceVOException {} 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 JpaSystemException {} 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-belum-verif", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianBelumVerif(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianSudahVerif(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getCatatanKegiatanHarianByIndikator(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "indikatorId") Integer idIndikator, @RequestParam(value = "bulan") Long bulan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getAksesPegawaiVerifikasiKinerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<BobotJenisIndikatorVO> saveBobotJenisIndikator(HttpServletRequest request,
			@Valid @RequestBody BobotJenisIndikatorVO vo) {
		try {
			BobotJenisIndikatorVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "periode") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getEditMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "tglPembaharuanData") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deleteMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "noRec") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deleteAllMasterBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "tglPembaharuanData") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Double>> getBobotJenisIndikatorByJabatan(HttpServletRequest request,
			@RequestParam(value = "periode") Long periode, @RequestParam(value = "jabatanId") Integer idJabatan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatBobotJenisIndikator(HttpServletRequest request,
			@RequestParam(value = "periode") Long periode,
			@RequestParam(value = "jenisIndikatorId") Integer idJenisIndikator,
			@RequestParam(value = "kelompokJabatanId", required = false) Integer idKelompokJabatan) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringDokterJamKerja(HttpServletRequest request,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailPasienDetailJamKerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai,
			@RequestParam(value = "indikatorId") Integer idIndikator,
			@RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "tglPelayanan") String tglPelayanan,
			@RequestParam(value = "jenisPetugasId") Integer idJenisPetugas, @RequestParam(value = "skor") Double skor) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringDokterLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailPasienDetailLuarJamKerja(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai,
			@RequestParam(value = "indikatorId") Integer idIndikator,
			@RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "tglPelayanan") String tglPelayanan,
			@RequestParam(value = "jenisPetugasId") Integer idJenisPetugas, @RequestParam(value = "skor") Double skor) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getPenilaianKinerjaIndividu(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "jabatanId") Integer idJabatan,
			@RequestParam(value = "bulan") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getRekapPenilaianKinerjaIndividu(HttpServletRequest request,
			@RequestParam(value = "bulan") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} when verifikasi logbook skor", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when verifikasi logbook skor", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/pegawai-remun-unit-kerja", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getPegawaiRemunByUnitKerja(HttpServletRequest request,
			@RequestParam(value = "unitKerjaId", required = false) Integer idUnitKerja,
			@RequestParam(value = "subunitKerjaId", required = false) Integer idSubunitKerja) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanPerawatVO> saveSkoringTindakanPerawat(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanPerawatVO vo) {
		try {
			SkoringTindakanPerawatVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk") String namaProduk, @RequestParam(value = "skor") Double skor,
			@RequestParam(value = "tglBerlaku") Long tglMulaiBerlaku) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanPerawat(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananPasienPerawatVO> savePelayananPasienPerawat(HttpServletRequest request,
			@Valid @RequestBody PelayananPasienPerawatVO vo) {
		try {
			PelayananPasienPerawatVO result;
			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 {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_ERROR,
						getMessage(MessageResource.LABEL_ERROR, request));
				return RestUtil.getJsonHttptatus(HttpStatus.BAD_REQUEST, mapHeaderMessage);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deletePelayananPasienPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getPelayananPasienPerawat(HttpServletRequest request,
			@RequestParam(value = "noRec") String noRec, @RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<ProdukPerawatVO> saveProdukPerawat(HttpServletRequest request,
			@Valid @RequestBody ProdukPerawatVO vo) {
		try {
			ProdukPerawatVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatProdukPerawat(HttpServletRequest request,
			@RequestParam(value = "namaProduk") String namaProduk, @RequestParam(value = "kdKlasif") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<ProfesiVO> saveProfesiNakes(HttpServletRequest request, @Valid @RequestBody ProfesiVO vo) {
		try {
			ProfesiVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<ProdukNakesVO> saveProdukNakes(HttpServletRequest request,
			@Valid @RequestBody ProdukNakesVO vo) {
		try {
			ProdukNakesVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatProdukNakes(HttpServletRequest request,
			@RequestParam(value = "namaProduk") String namaProduk, @RequestParam(value = "profesiId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanNakesVO> saveSkoringTindakanNakes(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanNakesVO vo) {
		try {
			SkoringTindakanNakesVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = 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) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanNakes(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk") String namaProduk, @RequestParam(value = "profesiId") Integer idProfesi,
			@RequestParam(value = "skor") Double skor, @RequestParam(value = "tglBerlaku") Long tglMulaiBerlaku) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanNakes(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananPasienNakesVO> savePelayananPasienNakes(HttpServletRequest request,
			@Valid @RequestBody PelayananPasienNakesVO vo) {
		try {
			PelayananPasienNakesVO result;
			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 {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_ERROR,
						getMessage(MessageResource.LABEL_ERROR, request));
				return RestUtil.getJsonHttptatus(HttpStatus.BAD_REQUEST, mapHeaderMessage);
			}
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deletePelayananPasienNakes(HttpServletRequest request,
			@RequestParam(value = "noRec") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getPelayananPasienNakes(HttpServletRequest request,
			@RequestParam(value = "noRec") String noRec, @RequestParam(value = "pegawaiId") Integer idPegawai) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananNakesVO> savePelayananNakes(HttpServletRequest request,
			@Valid @RequestBody PelayananNakesVO vo) {
		try {
			PelayananNakesVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deletePelayananNakes(HttpServletRequest request,
			@RequestParam(value = "noRec") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<TargetSkorDokterVO> saveTargetSkorDokter(HttpServletRequest request,
			@Valid @RequestBody TargetSkorDokterVO vo) {
		try {
			TargetSkorDokterVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getTargetSkorKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "tahun") Long tahun) {
		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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringNakes(HttpServletRequest request,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "pegawaiId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookSkoringNakes(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "tglPelayanan") 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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<Map<String, String>> getDeskripsiTindakanSkorMedis(HttpServletRequest request,
			@RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "kelompokKerjaId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringPerawat(HttpServletRequest request,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "pegawaiId") 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookSkoringPerawat(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "tglPelayanan") 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = 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 ServiceVOException {} 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 JpaSystemException {} 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 = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<MapProdukKelompokKerjaVO> saveMapProdukKelompokKerja(HttpServletRequest request,
			@Valid @RequestBody MapProdukKelompokKerjaVO vo) {
		try {
			MapProdukKelompokKerjaVO result;
			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 ServiceVOException {} 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 JpaSystemException {} 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 = POST)
	public ResponseEntity<Boolean> deleteMapProdukKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "noRec") 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 ServiceVOException {} 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 JpaSystemException {} 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 = 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 ServiceVOException {} 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 JpaSystemException {} 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 = GET)
	public ResponseEntity<List<Map<String, Object>>> getObjectMapProdukKelompokKerja(HttpServletRequest request,
			@RequestParam(value = "produkId") 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 ServiceVOException {} 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 JpaSystemException {} when get object map produk - kelompok kerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-produk-farmakologi", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<ProdukFarmakologiVO> saveProdukFarmakologi(HttpServletRequest request,
			@Valid @RequestBody ProdukFarmakologiVO vo) {
		try {
			ProdukFarmakologiVO result;
			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				result = produkFarmakologiService.update(vo);
			} else {
				result = produkFarmakologiService.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 ServiceVOException {} when add/update master produk kelompok kerja farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when add/update master produk kelompok kerja farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

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

	@RequestMapping(value = "/get-duplicate-produk-farmakolgi", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatProdukFarmakologi(HttpServletRequest request,
			@RequestParam(value = "namaProduk") String namaProduk,
			@RequestParam(value = "produkId", required = false) Integer idProduk) {
		try {
			List<Map<String, Object>> result = produkFarmakologiService.findDupProdukFarmakologi(namaProduk, 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 ServiceVOException {} when get duplikat produk kelompok kerja farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get duplikat produk kelompok kerja farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-skoring-tindakan-farmakologi", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<SkoringTindakanFarmakologiVO> saveSkoringTindakanFarmakologi(HttpServletRequest request,
			@Valid @RequestBody SkoringTindakanFarmakologiVO vo) {
		try {
			SkoringTindakanFarmakologiVO result;
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = skoringTindakanFarmakologiService.update(vo);
			} else {
				result = skoringTindakanFarmakologiService.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 ServiceVOException {} when add/update skor tindakan oleh kelompok kerja farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when add/update skor tindakan oleh kelompok kerja farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

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

	@RequestMapping(value = "/get-duplicate-skoring-tindakan-farmakologi", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getDuplikatSkoringTindakanFarmakologi(HttpServletRequest request,
			@RequestParam(value = "noRec", required = false) String noRec,
			@RequestParam(value = "namaProduk") String namaProduk, @RequestParam(value = "skor") Double skor,
			@RequestParam(value = "tglBerlaku") Long tglMulaiBerlaku) {
		try {
			List<Map<String, Object>> result = skoringTindakanFarmakologiService.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 ServiceVOException {} when get duplikat skoring tindakan oleh kelompok kerja farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get duplikat skoring tindakan oleh kelompok kerja farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-akses-skoring-tindakan-farmakologi", method = GET)
	public ResponseEntity<Map<String, Object>> getAksesSkoringTindakanFarmakologi(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai) {
		try {
			Map<String, Object> result = skoringTindakanFarmakologiService.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 ServiceVOException {} when get akses skoring tindakan oleh kelompok kerja farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get akses skoring tindakan oleh kelompok kerja farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/save-pelayanan-farmakologi", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<PelayananFarmakologiVO> savePelayananFarmakologi(HttpServletRequest request,
			@Valid @RequestBody PelayananFarmakologiVO vo) {
		try {
			PelayananFarmakologiVO result;
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRec())) {
				result = pelayananFarmakologiService.update(vo);
			} else {
				result = pelayananFarmakologiService.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 ServiceVOException {} when add/update pelayanan oleh dokter farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when add/update pelayanan oleh dokter farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/delete-pelayanan-farmakologi", method = POST)
	public ResponseEntity<Boolean> deletePelayananFarmakologi(HttpServletRequest request,
			@RequestParam(value = "noRec") String norec) {
		try {
			Boolean result = pelayananFarmakologiService.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 ServiceVOException {} when delete pelayanan oleh dokter farmakologi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when delete pelayanan oleh dokter farmakologi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-logbook-skoring-farmakologi", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookSkoringFarmakologi(HttpServletRequest request,
			@RequestParam(value = "bulan") Long bulan, @RequestParam(value = "pegawaiId") Integer idPegawai) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findLogbookFarmakologi(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 ServiceVOException {} when get logbook skoring dokter farmakologi", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook skoring dokter farmakologi", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/get-detail-logbook-skoring-farmakologi", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookSkoringFarmakologi(HttpServletRequest request,
			@RequestParam(value = "pegawaiId") Integer idPegawai, @RequestParam(value = "produkId") Integer idProduk,
			@RequestParam(value = "tglPelayanan") String tglPelayanan) {
		try {
			List<Map<String, Object>> result = logbookKinerjaService.findDetailLogbookFarmakologi(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 ServiceVOException {} when get detail logbook skoring dokter farmakologi",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get detail logbook skoring dokter farmakologi",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/verify-penilaian-kinerja-individu", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<PenilaianKinerjaVO> verifyPenilaianKinerjaIndividu(HttpServletRequest request,
			@Valid @RequestBody PenilaianKinerjaVO vo) {
		try {
			PenilaianKinerjaVO result = penilaianKinerjaService.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 ServiceVOException {} when verify 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 JpaSystemException {} when verify penilaian kinerja individu", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/remun/{idPegawai}/{bulan}", method = GET)
	public ResponseEntity<Map<String, Object>> getLogbookRemunTarifDokter(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @PathVariable("bulan") String bulan) {
		try {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
			YearMonth oct24 = YearMonth.parse("2024-10", formatter);
			YearMonth month = YearMonth.parse(bulan, formatter);
			Map<String, Object> result;
			if (month.isBefore(oct24)) {
				result = pelayananPasienService.logbookRemunTarifDokter(idPegawai, bulan, null);
			} else {
				result = remunerasiService.logbookRemunTarifDokter(idPegawai, bulan, null);
			}
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when get logbook remun tarif dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook remun tarif dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/ffs/{idPegawai}/{bulan}", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookFfsTarifDokter(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @PathVariable("bulan") String bulan) {
		try {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
			YearMonth oct24 = YearMonth.parse("2024-10", formatter);
			YearMonth month = YearMonth.parse(bulan, formatter);
			List<Map<String, Object>> result;
			if (month.isBefore(oct24)) {
				result = pelayananPasienService.logbookFfsTarifDokter(idPegawai, bulan, null);
			} else {
				result = remunerasiService.logbookFfsTarifDokter(idPegawai, bulan, null);
			}
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when get logbook ffs tarif dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook ffs tarif dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/ffs-luar/{idPegawai}/{bulan}", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookFfsLuarTarifDokter(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @PathVariable("bulan") String bulan) {
		try {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
			YearMonth oct24 = YearMonth.parse("2024-10", formatter);
			YearMonth month = YearMonth.parse(bulan, formatter);
			List<Map<String, Object>> result;
			if (month.isBefore(oct24)) {
				result = pelayananPasienService.logbookFfsLuarTarifDokter(idPegawai, bulan, null);
			} else {
				result = remunerasiService.logbookFfsLuarTarifDokter(idPegawai, bulan, null);
			}
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when get logbook ffs luar jam kerja tarif dokter",
					sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook ffs luar jam kerja tarif dokter",
					jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/klaim-mpp/{idPegawai}/{bulan}", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookKlaimMpp(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @PathVariable("bulan") String bulan) {
		try {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
			YearMonth oct24 = YearMonth.parse("2024-10", formatter);
			YearMonth month = YearMonth.parse(bulan, formatter);
			List<Map<String, Object>> result;
			if (month.isBefore(oct24)) {
				result = pelayananPasienService.logbookKlaimMppDokter(idPegawai, bulan);
			} else {
				result = remunerasiService.logbookKlaimMppDokter(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 ServiceVOException {} when get logbook klaim MPP tarif dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook klaim MPP tarif dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/fixed-pay/{idPegawai}/{bulan}", method = GET)
	public ResponseEntity<List<Map<String, Object>>> getLogbookFixedPay(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @PathVariable("bulan") String bulan) {
		try {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
			YearMonth oct24 = YearMonth.parse("2024-10", formatter);
			YearMonth month = YearMonth.parse(bulan, formatter);
			List<Map<String, Object>> result;
			if (month.isBefore(oct24)) {
				result = pelayananPasienService.logbookFixedPayDokter(idPegawai, bulan, null);
			} else {
				result = remunerasiService.logbookFixedPayDokter(idPegawai, bulan, null);
			}
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(result, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when get logbook fixed pay tarif dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logbook fixed pay tarif dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/dokter/logbook-tarif/detail/{idPegawai}", method = POST, produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
	public ResponseEntity<List<Map<String, Object>>> getDetailLogbookTarifDokter(HttpServletRequest request,
			@PathVariable("idPegawai") Integer idPegawai, @RequestBody List<String> norecs) {
		try {
			List<Map<String, Object>> result = pelayananPasienService.detailLogbookTarifDokter(idPegawai, norecs);
			if (CommonUtil.isNotNullOrEmpty(result)) {
				mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS_OK,
						getMessage(MessageResource.LABEL_SUCCESS_OK, request));
				return RestUtil.getJsonResponse(result, HttpStatus.OK, 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 ServiceVOException {} when get detail logbook tarif dokter", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get detail logbook tarif dokter", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/catatan-kinerja/{norec}", method = POST)
	public ResponseEntity<LogbookKinerjaDetailVO> saveWorkingRecord(HttpServletRequest request,
			@PathVariable("norec") String noRec) {
		try {
			logbookKinerjaDetailService.hapusCatatanKinerja(noRec);
			return RestUtil.getJsonResponse(null, HttpStatus.CREATED, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when hapus catatan kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when hapus catatan kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}

	@RequestMapping(value = "/catatan-kinerja/logs", method = GET)
	public ResponseEntity<Page<LogbookKinerjaDetailLogDto>> logsKinerja(HttpServletRequest request,
			@RequestParam(value = "indikator", required = false) String indikator,
			@RequestParam(value = "kegiatan", required = false) String kegiatan,
			@RequestParam(value = "tgl_awal_kegiatan", required = false) String tglAwalKegiatan,
			@RequestParam(value = "tgl_akhir_kegiatan", required = false) String tglAkhirKegiatan,
			@RequestParam(value = "pegawai", required = false) String pegawai, @RequestParam(value = "page") int page,
			@RequestParam(value = "size") int size) {
		try {
			Pageable pageable = new PageRequest(page, size);
			Long startDate = null;
			Long endDate = null;
			if (CommonUtil.isNotNullOrEmpty(tglAwalKegiatan) && CommonUtil.isNotNullOrEmpty(tglAkhirKegiatan)) {
				startDate = Long.parseLong(tglAwalKegiatan);
				endDate = Long.parseLong(tglAkhirKegiatan);
			}
			Page<LogbookKinerjaDetailLogDto> dtoPage = logbookLogService.search(indikator, kegiatan, startDate,
					endDate, pegawai, pageable);
			mapHeaderMessage.put(WebConstants.HttpHeaderInfo.LABEL_SUCCESS,
					getMessage(MessageResource.LABEL_SUCCESS, request));
			return RestUtil.getJsonResponse(dtoPage, HttpStatus.OK, mapHeaderMessage);
		} catch (ServiceVOException sve) {
			LOGGER.error("Got ServiceVOException {} when get logging catatan kinerja", sve.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, sve.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.INTERNAL_SERVER_ERROR, mapHeaderMessage);
		} catch (JpaSystemException jse) {
			LOGGER.error("Got JpaSystemException {} when get logging catatan kinerja", jse.getMessage());
			addHeaderMessage(Constants.MessageInfo.ERROR_MESSAGE, jse.getMessage());
			return RestUtil.getJsonHttptatus(HttpStatus.CONFLICT, mapHeaderMessage);
		}
	}
}