package com.jasamedika.medifirst2000.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.google.gson.Gson;
import com.jasamedika.medifirst2000.constants.Master;
import com.jasamedika.medifirst2000.converter.BaseConverterImpl;
import com.jasamedika.medifirst2000.dao.EvaluasiJabatanDao;
import com.jasamedika.medifirst2000.dao.HistoryDataPegawaiDao;
import com.jasamedika.medifirst2000.dao.JabatanDao;
import com.jasamedika.medifirst2000.dao.JenisJabatanDao;
import com.jasamedika.medifirst2000.dao.KategoryPegawaiDao;
import com.jasamedika.medifirst2000.dao.MapPegawaiJabatanToUnitKerjaDao;
import com.jasamedika.medifirst2000.dao.MapPegawaiJabatanToUnitKerjaHistoriDao;
import com.jasamedika.medifirst2000.dao.NilaiKelompokJabatanDao;
import com.jasamedika.medifirst2000.dao.PegawaiDao;
import com.jasamedika.medifirst2000.dao.SubUnitKerjaDao;
import com.jasamedika.medifirst2000.dao.UnitKerjaDao;
import com.jasamedika.medifirst2000.entities.HistoryDataPegawai;
import com.jasamedika.medifirst2000.entities.Jabatan;
import com.jasamedika.medifirst2000.entities.LoginUser;
import com.jasamedika.medifirst2000.entities.MapPegawaiJabatanToUnitKerja;
import com.jasamedika.medifirst2000.entities.MapPegawaiJabatanToUnitKerjaHistori;
import com.jasamedika.medifirst2000.entities.NilaiKelompokJabatan;
import com.jasamedika.medifirst2000.entities.Pegawai;
import com.jasamedika.medifirst2000.entities.SubUnitKerjaPegawai;
import com.jasamedika.medifirst2000.entities.UnitKerjaPegawai;
import com.jasamedika.medifirst2000.service.LoginUserService;
import com.jasamedika.medifirst2000.service.MapPegawaiJabatanToUnitKerjaService;
import com.jasamedika.medifirst2000.service.MappingPegawaiToAtasanService;
import com.jasamedika.medifirst2000.service.RiwayatJabatanService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.vo.JabatanVO;
import com.jasamedika.medifirst2000.vo.MapPegawaiJabatanToUnitKerjaVO;
import com.jasamedika.medifirst2000.vo.MappingPegawaiToAtasanVO;
import com.jasamedika.medifirst2000.vo.PegawaiVO;
import com.jasamedika.medifirst2000.vo.RiwayatJabatanVO;
import com.jasamedika.medifirst2000.vo.SubUnitKerjaPegawaiVO;
import com.jasamedika.medifirst2000.vo.UnitKerjaPegawaiVO;

@Service("MapPegawaiJabatanToUnitKerjaService")
public class MapPegawaiJabatanToUnitKerjaServiceImpl implements MapPegawaiJabatanToUnitKerjaService {

	@Autowired
	private MappingPegawaiToAtasanService mappingPegawaiToAtasanService;

	@Autowired
	private LoginUserService loginUserService;

	@Autowired
	private RiwayatJabatanService riwayatJabatanService;

	@Autowired
	private MapPegawaiJabatanToUnitKerjaDao mapPegawaiJabatanToUnitKerjaDao;

	@Autowired
	private MapPegawaiJabatanToUnitKerjaHistoriDao mapPegawaiJabatanToUnitKerjaHistoriDao;

	@Autowired
	private PegawaiDao pegawaiDao;

	@Autowired
	private UnitKerjaDao unitKerjaDao;

	@Autowired
	private SubUnitKerjaDao subUnitKerjaDao;

	@Autowired
	private JenisJabatanDao jenisJabatanDao;

	@Autowired
	private JabatanDao jabatanDao;

	@Autowired
	private KategoryPegawaiDao kategoryPegawaiDao;

	@Autowired
	private HistoryDataPegawaiDao historyDataPegawaiDao;

	@Autowired
	private EvaluasiJabatanDao evaluasiJabatanDao;

	@Autowired
	private NilaiKelompokJabatanDao nilaiKelompokJabatanDao;

	@Autowired
	private BaseConverterImpl<PegawaiVO, Pegawai> pegawaiConverter;

	@Autowired
	private BaseConverterImpl<JabatanVO, Jabatan> jabatanConverter;

	@Autowired
	private BaseConverterImpl<SubUnitKerjaPegawaiVO, SubUnitKerjaPegawai> subunitKerjaConverter;

	@Autowired
	private BaseConverterImpl<UnitKerjaPegawaiVO, UnitKerjaPegawai> unitKerjaConverter;

	@Autowired
	private BaseConverterImpl<MapPegawaiJabatanToUnitKerjaVO, MapPegawaiJabatanToUnitKerja> mapPegawaiJabatanToUnitKerjaConverter;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> save(List<MapPegawaiJabatanToUnitKerjaVO> listVo) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> listResult = new ArrayList<Map<String, Object>>();
		if (CommonUtil.isNotNullOrEmpty(listVo)) {
			for (MapPegawaiJabatanToUnitKerjaVO vo : listVo) {

				String perubahan = "";
				Integer idKategoryPegawai = 0;

				Map<String, Object> tmp = new HashMap<>();
				MapPegawaiJabatanToUnitKerja map = new MapPegawaiJabatanToUnitKerja();
				Pegawai pegawai = new Pegawai();
				if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
					map = mapPegawaiJabatanToUnitKerjaDao.findOne(vo.getId());

					// get_kategory_pegawai
					pegawai = pegawaiDao.findOne(map.getPegawaiId());
					idKategoryPegawai = pegawai.getKategoryPegawaiId();
				}
				if (CommonUtil.isNotNullOrEmpty(map.getId())) {
					// update
					if (CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
						map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
						perubahan += "akses buat jadwal, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getStatusEnabled())) {
						map.setStatusEnabled(vo.getStatusEnabled());
						if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
							perubahan += "hapus mapping dokter penanggung jawab, ";
						} else {
							perubahan += "hapus mapping jabatan, ";
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
						map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
						map.setAtasanLangsung(
								pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
						perubahan += "atasan langsung, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
						map.setPejabatPenilai(
								pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
						perubahan += "pejabat penilai, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
						map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
						perubahan += "atasan langsung direksi, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
						map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
						perubahan += "pejabat penilai direksi, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
						map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
						perubahan += "jabatan, ";

						// Find nilai jabatan dan grade
						List<Map<String, Object>> ej = evaluasiJabatanDao
								.findEvaluasiByJabatan(vo.getJabatan().getId());
						if (CommonUtil.isNotNullOrEmpty(ej)) {
							map.setNilaiJabatan(Double.valueOf(ej.get(0).get("totalNilai").toString()));
							NilaiKelompokJabatan nj = new NilaiKelompokJabatan();
							nj.setId(Integer.valueOf(ej.get(0).get("gradeId").toString()));
							map.setGrade(nj);
							perubahan += "hitung nilai jabatan, grade jabatan ";
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
						map.setUnitKerjaPegawai(
								unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
						perubahan += "unit kerja, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
						map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
								new SubUnitKerjaPegawai()));
						perubahan += "subunit kerja, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
						map.setIsMonitoring(vo.getIsMonitoring());
						perubahan += "akses monitoring, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
						if (vo.getIsPrimary()) {
							disableIsprimary(vo.getPegawai().getId(), vo.getId());
						}
						map.setIsPrimary(vo.getIsPrimary());
						perubahan += "akses jabatan utama, ";
					}
					map = mapPegawaiJabatanToUnitKerjaDao.save(map);
					this.saveHistoryPegawai(map, perubahan);
				} else {
					// save
					map = new MapPegawaiJabatanToUnitKerja();
					map.setKdProfile((short) 0);
					map.setKodeExternal("");
					map.setNamaExternal("");

					if (CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
						map.setIsMonitoring(vo.getIsMonitoring());
						perubahan += "akses monitoring, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
						if (vo.getIsPrimary()) {
							disableIsprimary(vo.getPegawai().getId());
						}
						map.setIsPrimary(vo.getIsPrimary());
						perubahan += "akses jabatan utama, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
						map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
						perubahan += "akses dapat buat jadwal, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getStatusEnabled())) {
						map.setStatusEnabled(vo.getStatusEnabled());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
						map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
					}

					if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
						map.setAtasanLangsung(
								pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
						perubahan += "atasan langsung, ";
					}

					if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
						map.setPejabatPenilai(
								pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
						perubahan += "pejabat penilai, ";
					}

					if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
						map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
						perubahan += "atasan langsung direksi, ";
					}

					if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
						map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
						perubahan += "pejabat penilai direksi, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
						map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
						perubahan += "jabatan, ";

						// Find nilai jabatan dan grade
						List<Map<String, Object>> ej = evaluasiJabatanDao
								.findEvaluasiByJabatan(vo.getJabatan().getId());
						if (CommonUtil.isNotNullOrEmpty(ej)) {
							map.setNilaiJabatan(Double.valueOf(ej.get(0).get("totalNilai").toString()));
							NilaiKelompokJabatan nj = new NilaiKelompokJabatan();
							nj.setId(Integer.valueOf(ej.get(0).get("gradeId").toString()));
							map.setGrade(nj);
							perubahan += "hitung nilai jabatan, grade jabatan ";
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
						map.setUnitKerjaPegawai(
								unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
						perubahan += "unit kerja, ";
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
						map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
								new SubUnitKerjaPegawai()));
						perubahan += "subunit kerja, ";
					}
					map = mapPegawaiJabatanToUnitKerjaDao.save(map);
					this.saveHistoryPegawai(map, perubahan);
				}
				tmp.put("id", map.getId());
				listResult.add(tmp);

				// update_komponen_evaluasi_jabatan
				if (CommonUtil.isNotNullOrEmpty(map.getPegawaiId())) {
					Map<String, Object> evaluasiJabatan = this.getEvaluasiJabatanByPegawai(map.getPegawaiId());
					pegawai.setId(map.getPegawaiId());
					if ((CommonUtil.isNotNullOrEmpty(evaluasiJabatan)
							&& CommonUtil.isNullOrEmpty(pegawai.getNilaiJabatan()))
							|| (CommonUtil.isNotNullOrEmpty(evaluasiJabatan)
									&& CommonUtil.isNotNullOrEmpty(pegawai.getNilaiJabatan())
									&& pegawai.getNilaiJabatan() < Double
											.valueOf(evaluasiJabatan.get("nilaiJabatan").toString()))) {
						pegawai.setNilaiJabatan(Double.valueOf(evaluasiJabatan.get("nilaiJabatan").toString()));
						pegawai.setGrade(Double.valueOf(evaluasiJabatan.get("grade").toString()));
						NilaiKelompokJabatan detailKelompokJabatan = new NilaiKelompokJabatan();
						detailKelompokJabatan
								.setId(Integer.valueOf(evaluasiJabatan.get("idDetailKelompokJabatan").toString()));
						pegawai.setDetailKelompokJabatan(detailKelompokJabatan);
					} else {
						pegawai.setNilaiJabatan(null);
						pegawai.setGrade(null);
						pegawai.setDetailKelompokJabatan(null);

					}
					Pegawai rs = pegawaiDao.save(pegawai);
					if (CommonUtil.isNotNullOrEmpty(rs)) {
						listResult.add(evaluasiJabatan);
					}
				}

				// setting jabatan utama
				if (CommonUtil.isNotNullOrEmpty(map.getPegawaiId())) {
					List<Map<String, Object>> lnj = mapPegawaiJabatanToUnitKerjaDao
							.findNilaiJabatanByPegawai(map.getPegawaiId());
					if (lnj.size() > 1) {
						if (!Boolean.valueOf(lnj.get(0).get("isPrimary").toString())) {
							mapPegawaiJabatanToUnitKerjaDao.changeIsNotPrimary(map.getPegawaiId(),
									Integer.valueOf(lnj.get(0).get("id").toString()));
							mapPegawaiJabatanToUnitKerjaDao.changeIsPrimary(map.getPegawaiId(),
									Integer.valueOf(lnj.get(0).get("id").toString()));
						}
					} else if (lnj.size() == 1) {
						mapPegawaiJabatanToUnitKerjaDao.changeIsPrimary(map.getPegawaiId(),
								Integer.valueOf(lnj.get(0).get("id").toString()));
					}

				}
			}
		}
		result.put("data", listResult);
		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> saveRev(List<MapPegawaiJabatanToUnitKerjaVO> listVo) {
		Map<String, Object> result = new HashMap<>();

		List<Map<String, Object>> listResult = new ArrayList<Map<String, Object>>();

		String perubahan = "";

		for (MapPegawaiJabatanToUnitKerjaVO vo : listVo) {
			MapPegawaiJabatanToUnitKerja map = new MapPegawaiJabatanToUnitKerja();
			Map<String, Object> tmp = new HashMap<>();

			// exceptional dynamic data entry
			if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
				if (vo.getJabatan().getId().equals(Master.EMPTY_DATA)) {
					vo.setJabatan(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
				if (vo.getUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
					vo.setUnitKerjaPegawai(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
				if (vo.getSubUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
					vo.setSubUnitKerjaPegawai(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
				if (vo.getAtasanLangsung().getId().equals(Master.EMPTY_DATA)) {
					vo.setAtasanLangsung(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
				if (vo.getPejabatPenilai().getId().equals(Master.EMPTY_DATA)) {
					vo.setPejabatPenilai(null);
				}
			}

			// get_kategory_pegawai
			Pegawai pegawai = pegawaiDao.findOne(vo.getPegawai().getId());
			Integer idKategoryPegawai = pegawai.getKategoryPegawaiId();

			if (CommonUtil.isNotNullOrEmpty(vo.getId())) {
				map = mapPegawaiJabatanToUnitKerjaDao.findOne(vo.getId());

				map.setId(vo.getId());
				map.setKdProfile(Master.KODE_PROFILE);

				if (CommonUtil.isNotNullOrEmpty(map.getStatusEnabled())
						&& CommonUtil.isNotNullOrEmpty(vo.getStatusEnabled())) {
					if (!map.getStatusEnabled().equals(vo.getStatusEnabled())) {
						map.setStatusEnabled(vo.getStatusEnabled());
						if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
							perubahan += "status hapus mapping dokter penanggung jawab, ";
						} else {
							perubahan += "status hapus mapping jabatan, ";
						}
					}
				} else if (CommonUtil.isNullOrEmpty(map.getStatusEnabled())
						&& CommonUtil.isNotNullOrEmpty(vo.getStatusEnabled())) {
					map.setStatusEnabled(vo.getStatusEnabled());
					if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "status hapus mapping dokter penanggung jawab, ";
					} else {
						perubahan += "status hapus mapping jabatan, ";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(map.getPegawaiId()) && CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					if (!map.getPegawaiId().equals(vo.getPegawai().getId())) {
						map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
					}
				} else if (CommonUtil.isNullOrEmpty(map.getPegawaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}

				if (CommonUtil.isNotNullOrEmpty(map.getSumberData())
						&& CommonUtil.isNotNullOrEmpty(vo.getSumberData())) {
					if (!map.getSumberData().equals(vo.getSumberData())) {
						map.setSumberData(vo.getSumberData());
						perubahan += "ubah sumber data penetapan jabatan, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getSumberData())
						&& CommonUtil.isNotNullOrEmpty(vo.getSumberData())) {
					map.setSumberData(vo.getSumberData());
					perubahan += "sumber data penetapan jabatan, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getSumberData())
						&& CommonUtil.isNullOrEmpty(vo.getSumberData())) {
					map.setSumberData(vo.getSumberData());
					perubahan += "hapus sumber data penetapan jabatan, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getJabatanId()) && CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
					if (!map.getJabatanId().equals(vo.getJabatan().getId())) {
						map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
						perubahan += "ubah jabatan, ";

						RiwayatJabatanVO riwayatJabatanVo = new RiwayatJabatanVO();
						riwayatJabatanVo.setTglSK(new Date());
						riwayatJabatanVo.setJabatan(vo.getJabatan());
						riwayatJabatanVo.setNamaJabatan(vo.getJabatan().getNamaJabatan());
						riwayatJabatanVo.setPegawai(vo.getPegawai());
						riwayatJabatanVo.setSumberData(vo.getSumberData());
						riwayatJabatanVo.setStatusEnabled(Master.STATUS_ENABLE_TRUE);
						riwayatJabatanService.add(riwayatJabatanVo);

						// Find nilai jabatan dan grade
						List<Map<String, Object>> ej = evaluasiJabatanDao
								.findEvaluasiByJabatan(vo.getJabatan().getId());
						if (CommonUtil.isNotNullOrEmpty(ej)) {
							map.setNilaiJabatan(Double.valueOf(ej.get(0).get("totalNilai").toString()));
							NilaiKelompokJabatan nj = new NilaiKelompokJabatan();
							nj.setId(Integer.valueOf(ej.get(0).get("gradeId").toString()));
							map.setGrade(nj);
							perubahan += "hitung ulang nilai jabatan, ubah grade jabatan ";
						}
					}
				} else if (CommonUtil.isNullOrEmpty(map.getJabatanId())
						&& CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
					map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
					perubahan += "jabatan, ";

					RiwayatJabatanVO riwayatJabatanVo = new RiwayatJabatanVO();
					riwayatJabatanVo.setTglSK(new Date());
					riwayatJabatanVo.setJabatan(vo.getJabatan());
					riwayatJabatanVo.setNamaJabatan(vo.getJabatan().getNamaJabatan());
					riwayatJabatanVo.setPegawai(vo.getPegawai());
					riwayatJabatanVo.setSumberData(vo.getSumberData());
					riwayatJabatanVo.setStatusEnabled(Master.STATUS_ENABLE_TRUE);
					riwayatJabatanService.add(riwayatJabatanVo);

					// Find nilai jabatan dan grade
					List<Map<String, Object>> ej = evaluasiJabatanDao.findEvaluasiByJabatan(vo.getJabatan().getId());
					if (CommonUtil.isNotNullOrEmpty(ej)) {
						map.setNilaiJabatan(Double.valueOf(ej.get(0).get("totalNilai").toString()));
						NilaiKelompokJabatan nj = new NilaiKelompokJabatan();
						nj.setId(Integer.valueOf(ej.get(0).get("gradeId").toString()));
						map.setGrade(nj);
						perubahan += "hitung nilai jabatan, grade jabatan";
					}
				} else if (CommonUtil.isNotNullOrEmpty(map.getJabatanId())
						&& CommonUtil.isNullOrEmpty(vo.getJabatan())) {
					map.setJabatan(null);
					map.setNilaiJabatan(null);
					map.setGrade(null);
					perubahan += "hapus jabatan, hapus hasil hitung nilai jabatan, hapus grade jabatan";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getUnitKerjaPegawaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
					if (!map.getUnitKerjaPegawaiId().equals(vo.getUnitKerjaPegawai().getId())) {
						map.setUnitKerjaPegawai(
								unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
						perubahan += "ubah unit kerja, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getUnitKerjaPegawaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
					map.setUnitKerjaPegawai(
							unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
					perubahan += "unit kerja, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getUnitKerjaPegawaiId())
						&& CommonUtil.isNullOrEmpty(vo.getUnitKerjaPegawai())) {
					map.setUnitKerjaPegawai(null);
					perubahan += "hapus unit kerja, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getSubUnitKerjaPegawaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
					if (!map.getSubUnitKerjaPegawaiId().equals(vo.getSubUnitKerjaPegawai().getId())) {
						map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
								new SubUnitKerjaPegawai()));
						perubahan += "ubah subunit kerja, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getSubUnitKerjaPegawaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
					map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
							new SubUnitKerjaPegawai()));
					perubahan += "subunit kerja, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getSubUnitKerjaPegawaiId())
						&& CommonUtil.isNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
					map.setSubUnitKerjaPegawai(null);
					perubahan += "hapus subunit kerja, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getAtasanLangsungId())
						&& CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
					if (!map.getAtasanLangsungId().equals(vo.getAtasanLangsung().getId())) {
						map.setAtasanLangsung(
								pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
						if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
							perubahan += "ubah dokter penanggung jawab, ";
						} else {
							perubahan += "ubah atasan langsung, ";
						}
					}
				} else if (CommonUtil.isNullOrEmpty(map.getAtasanLangsungId())
						&& CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
					map.setAtasanLangsung(pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
					if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "dokter penanggung jawab, ";
					} else {
						perubahan += "atasan langsung, ";
					}
				} else if (CommonUtil.isNotNullOrEmpty(map.getAtasanLangsungId())
						&& CommonUtil.isNullOrEmpty(vo.getAtasanLangsung())) {
					map.setAtasanLangsung(null);
					if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "hapus dokter penanggung jawab, ";
					} else {
						perubahan += "hapus atasan langsung, ";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(map.getAtasanLangsungDireksi())
						&& CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
					if (!map.getAtasanLangsungDireksi().equals(vo.getAtasanLangsungDireksi())) {
						map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
						perubahan += "ubah atasan langsung direksi, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getAtasanLangsungDireksi())
						&& CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
					map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
					perubahan += "atasan langsung direksi, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getAtasanLangsungDireksi())
						&& CommonUtil.isNullOrEmpty(vo.getAtasanLangsungDireksi())) {
					map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
					perubahan += "hapus atasan langsung direksi, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getPejabatPenilaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
					if (!map.getPejabatPenilaiId().equals(vo.getPejabatPenilai().getId())) {
						map.setPejabatPenilai(
								pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
						perubahan += "ubah pejabat penilai, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getPejabatPenilaiId())
						&& CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
					map.setPejabatPenilai(pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
					perubahan += "pejabat penilai, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getPejabatPenilaiId())
						&& CommonUtil.isNullOrEmpty(vo.getPejabatPenilai())) {
					map.setPejabatPenilai(null);
					perubahan += "hapus pejabat penilai, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getPejabatPenilaiDireksi())
						&& CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
					if (!map.getPejabatPenilaiDireksi().equals(vo.getPejabatPenilaiDireksi())) {
						map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
						perubahan += "ubah pejabat penilai direksi, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getPejabatPenilaiDireksi())
						&& CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
					map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
					perubahan += "pejabat penilai direksi, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getPejabatPenilaiDireksi())
						&& CommonUtil.isNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
					map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
					perubahan += "hapus pejabat penilai direksi, ";
				}

				if (CommonUtil.isNotNullOrEmpty(map.getIsPrimary()) && CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
					if (!map.getIsPrimary().equals(vo.getIsPrimary())) {
						map.setIsPrimary(vo.getIsPrimary());
						if (vo.getIsPrimary()) {
							disableIsprimary(vo.getPegawai().getId(), vo.getId());
						}
						perubahan += "ubah status jabatan utama, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getIsPrimary())
						&& CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
					map.setIsPrimary(vo.getIsPrimary());
					if (vo.getIsPrimary()) {
						disableIsprimary(vo.getPegawai().getId(), vo.getId());
					}
					perubahan += "status jabatan utama, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getIsPrimary())
						&& CommonUtil.isNullOrEmpty(vo.getIsPrimary())) {
					map.setIsPrimary(false);
				}

				if (CommonUtil.isNotNullOrEmpty(map.getIsMonitoring())
						&& CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
					if (!map.getIsMonitoring().equals(vo.getIsMonitoring())) {
						map.setIsMonitoring(vo.getIsMonitoring());
						perubahan += "ubah status monitoring, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getIsMonitoring())
						&& CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
					map.setIsMonitoring(vo.getIsMonitoring());
					perubahan += "status monitoring, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getIsMonitoring())
						&& CommonUtil.isNullOrEmpty(vo.getIsMonitoring())) {
					map.setIsMonitoring(false);
				}

				if (CommonUtil.isNotNullOrEmpty(map.getIsCanCreateJadwal())
						&& CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
					if (!map.getIsCanCreateJadwal().equals(vo.getIsCanCreateJadwal())) {
						map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
						perubahan += "ubah status buat jadwal dinas, ";
					}
				} else if (CommonUtil.isNullOrEmpty(map.getIsCanCreateJadwal())
						&& CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
					map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
					perubahan += "status buat jadwal dinas, ";
				} else if (CommonUtil.isNotNullOrEmpty(map.getIsCanCreateJadwal())
						&& CommonUtil.isNullOrEmpty(vo.getIsCanCreateJadwal())) {
					map.setIsCanCreateJadwal(false);
				}

				if (CommonUtil.isNullOrEmpty(perubahan)) {
					result.put("data", Master.TIDAK_ADA_PERUBAHAN_DATA);
					return result;
				}

				map = mapPegawaiJabatanToUnitKerjaDao.save(map);
				this.saveHistoryPegawai(map, perubahan);
			} else {
				map.setKdProfile(Master.KODE_PROFILE);
				map.setStatusEnabled(Master.STATUS_ENABLE_TRUE);

				if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getSumberData())) {
					map.setSumberData(vo.getSumberData());
					perubahan += "sumber data penetapan jabatan, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
					map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
					perubahan += "jabatan, ";

					RiwayatJabatanVO riwayatJabatanVo = new RiwayatJabatanVO();
					riwayatJabatanVo.setTglSK(new Date());
					riwayatJabatanVo.setJabatan(vo.getJabatan());
					riwayatJabatanVo.setNamaJabatan(vo.getJabatan().getNamaJabatan());
					riwayatJabatanVo.setPegawai(vo.getPegawai());
					riwayatJabatanVo.setSumberData(vo.getSumberData());
					riwayatJabatanVo.setStatusEnabled(Master.STATUS_ENABLE_TRUE);
					riwayatJabatanService.add(riwayatJabatanVo);

					// Find nilai jabatan dan grade
					List<Map<String, Object>> ej = evaluasiJabatanDao.findEvaluasiByJabatan(vo.getJabatan().getId());
					if (CommonUtil.isNotNullOrEmpty(ej)) {
						map.setNilaiJabatan(Double.valueOf(ej.get(0).get("totalNilai").toString()));
						NilaiKelompokJabatan nj = new NilaiKelompokJabatan();
						nj.setId(Integer.valueOf(ej.get(0).get("gradeId").toString()));
						map.setGrade(nj);
						perubahan += "hitung nilai jabatan, grade jabatan";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
					map.setUnitKerjaPegawai(
							unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
					perubahan += "unit kerja, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
					map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
							new SubUnitKerjaPegawai()));
					perubahan += "subunit kerja, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
					map.setAtasanLangsung(pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
					if (idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "dokter penanggung jawab, ";
					} else {
						perubahan += "atasan langsung, ";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
					map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
					perubahan += "atasan langsung direksi, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
					map.setPejabatPenilai(pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
					perubahan += "pejabat penilai, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
					map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
					perubahan += "pejabat penilai direksi, ";
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
					map.setIsPrimary(vo.getIsPrimary());
					if (vo.getIsPrimary()) {
						disableIsprimary(vo.getPegawai().getId());
					}
					if (!idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "status jabatan utama, ";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
					map.setIsMonitoring(vo.getIsMonitoring());
					if (!idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "status monitoring, ";
					}
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
					map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
					if (!idKategoryPegawai.equals(Master.KategoryPegawai.PESERTA_DIDIK)) {
						perubahan += "status buat jadwal dinas, ";
					}
				}

				if (CommonUtil.isNullOrEmpty(perubahan)) {
					result.put("data", Master.TIDAK_ADA_PERUBAHAN_DATA);
					return result;
				}

				map = mapPegawaiJabatanToUnitKerjaDao.save(map);
				this.saveHistoryPegawai(map, perubahan);
			}

			tmp.put("id", map.getId());
			listResult.add(tmp);

			// update_komponen_evaluasi_jabatan
			if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
				Map<String, Object> evaluasiJabatan = this.getEvaluasiJabatanByPegawai(vo.getPegawai().getId());
				pegawai.setId(vo.getPegawai().getId());
				if (CommonUtil.isNotNullOrEmpty(evaluasiJabatan)) {
					pegawai.setNilaiJabatan(Double.valueOf(evaluasiJabatan.get("nilaiJabatan").toString()));
					pegawai.setGrade(Double.valueOf(evaluasiJabatan.get("grade").toString()));
					NilaiKelompokJabatan detailKelompokJabatan = new NilaiKelompokJabatan();
					detailKelompokJabatan
							.setId(Integer.valueOf(evaluasiJabatan.get("idDetailKelompokJabatan").toString()));
					pegawai.setDetailKelompokJabatan(detailKelompokJabatan);
				} else {
					pegawai.setNilaiJabatan(null);
					pegawai.setGrade(null);
					pegawai.setDetailKelompokJabatan(null);
				}
				Pegawai rs = pegawaiDao.save(pegawai);
				if (CommonUtil.isNotNullOrEmpty(rs)) {
					listResult.add(evaluasiJabatan);
				}
			}

			// setting jabatan utama
			if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
				List<Map<String, Object>> lnj = mapPegawaiJabatanToUnitKerjaDao
						.findNilaiJabatanByPegawai(vo.getPegawai().getId());
				if (lnj.size() > 1) {
					if (!Boolean.valueOf(lnj.get(0).get("isPrimary").toString())) {
						mapPegawaiJabatanToUnitKerjaDao.changeIsNotPrimary(vo.getPegawai().getId(),
								Integer.valueOf(lnj.get(0).get("id").toString()));
						mapPegawaiJabatanToUnitKerjaDao.changeIsPrimary(vo.getPegawai().getId(),
								Integer.valueOf(lnj.get(0).get("id").toString()));
					}
				} else if (lnj.size() == 1) {
					mapPegawaiJabatanToUnitKerjaDao.changeIsPrimary(vo.getPegawai().getId(),
							Integer.valueOf(lnj.get(0).get("id").toString()));
				}
			}

		}
		result.put("data", listResult);

		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> saveHistory(List<MapPegawaiJabatanToUnitKerjaVO> listVo) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> listResult = new ArrayList<Map<String, Object>>();

		LoginUser loginUser = loginUserService.getLoginUser();

		for (MapPegawaiJabatanToUnitKerjaVO vo : listVo) {
			MapPegawaiJabatanToUnitKerjaHistori map = new MapPegawaiJabatanToUnitKerjaHistori();
			Map<String, Object> tmp = new HashMap<>();

			// exceptional dynamic data entry
			if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
				if (vo.getJabatan().getId().equals(Master.EMPTY_DATA)) {
					vo.setJabatan(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
				if (vo.getUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
					vo.setUnitKerjaPegawai(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
				if (vo.getSubUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
					vo.setSubUnitKerjaPegawai(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
				if (vo.getAtasanLangsung().getId().equals(Master.EMPTY_DATA)) {
					vo.setAtasanLangsung(null);
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
				if (vo.getPejabatPenilai().getId().equals(Master.EMPTY_DATA)) {
					vo.setPejabatPenilai(null);
				}
			}

			map.setKdProfile(Master.KODE_PROFILE);
			map.setStatusEnabled(Master.STATUS_ENABLE_TRUE);

			if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
				map.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getJabatan())) {
				map.setJabatan(jabatanConverter.transferVOToModel(vo.getJabatan(), new Jabatan()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getUnitKerjaPegawai())) {
				map.setUnitKerjaPegawai(
						unitKerjaConverter.transferVOToModel(vo.getUnitKerjaPegawai(), new UnitKerjaPegawai()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getSubUnitKerjaPegawai())) {
				map.setSubUnitKerjaPegawai(subunitKerjaConverter.transferVOToModel(vo.getSubUnitKerjaPegawai(),
						new SubUnitKerjaPegawai()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsung())) {
				map.setAtasanLangsung(pegawaiConverter.transferVOToModel(vo.getAtasanLangsung(), new Pegawai()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getAtasanLangsungDireksi())) {
				map.setAtasanLangsungDireksi(vo.getAtasanLangsungDireksi());
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilai())) {
				map.setPejabatPenilai(pegawaiConverter.transferVOToModel(vo.getPejabatPenilai(), new Pegawai()));
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getPejabatPenilaiDireksi())) {
				map.setPejabatPenilaiDireksi(vo.getPejabatPenilaiDireksi());
			}

			// if (CommonUtil.isNotNullOrEmpty(vo.getIsPrimary())) {
			// map.setIsPrimary(vo.getIsPrimary());
			// if (vo.getIsPrimary()) {
			// disableIsprimary(vo.getPegawai().getId());
			// }
			// }

			// if (CommonUtil.isNotNullOrEmpty(vo.getIsMonitoring())) {
			// map.setIsMonitoring(vo.getIsMonitoring());
			// }

			// if (CommonUtil.isNotNullOrEmpty(vo.getIsCanCreateJadwal())) {
			// map.setIsCanCreateJadwal(vo.getIsCanCreateJadwal());
			// }

			if (CommonUtil.isNotNullOrEmpty(loginUser.getPegawai())) {
				map.setMappingId(vo.getId());
				map.setPegawaiInput(loginUser.getPegawai());
				map.setTglInput(new Date());
			}
			map = mapPegawaiJabatanToUnitKerjaHistoriDao.save(map);

			tmp.put("norec", map.getNoRec());
			listResult.add(tmp);
		}
		result.put("data", listResult);

		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> saveHistory(MapPegawaiJabatanToUnitKerja mapp) {
		Map<String, Object> result = new HashMap<>();
		MapPegawaiJabatanToUnitKerjaHistori map = new MapPegawaiJabatanToUnitKerjaHistori();

		LoginUser loginUser = loginUserService.getLoginUser();

		// exceptional dynamic data entry
		if (CommonUtil.isNotNullOrEmpty(mapp.getJabatan())) {
			if (mapp.getJabatan().getId().equals(Master.EMPTY_DATA)) {
				mapp.setJabatan(null);
			}
		}
		if (CommonUtil.isNotNullOrEmpty(mapp.getUnitKerjaPegawai())) {
			if (mapp.getUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
				mapp.setUnitKerjaPegawai(null);
			}
		}
		if (CommonUtil.isNotNullOrEmpty(mapp.getSubUnitKerjaPegawai())) {
			if (mapp.getSubUnitKerjaPegawai().getId().equals(Master.EMPTY_DATA)) {
				mapp.setSubUnitKerjaPegawai(null);
			}
		}
		if (CommonUtil.isNotNullOrEmpty(mapp.getAtasanLangsung())) {
			if (mapp.getAtasanLangsung().getId().equals(Master.EMPTY_DATA)) {
				mapp.setAtasanLangsung(null);
			}
		}
		if (CommonUtil.isNotNullOrEmpty(mapp.getPejabatPenilai())) {
			if (mapp.getPejabatPenilai().getId().equals(Master.EMPTY_DATA)) {
				mapp.setPejabatPenilai(null);
			}
		}

		map.setKdProfile(Master.KODE_PROFILE);
		map.setStatusEnabled(Master.STATUS_ENABLE_TRUE);

		if (CommonUtil.isNotNullOrEmpty(mapp.getPegawai())) {
			map.setPegawai(mapp.getPegawai());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getJabatan())) {
			map.setJabatan(mapp.getJabatan());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getUnitKerjaPegawai())) {
			map.setUnitKerjaPegawai(mapp.getUnitKerjaPegawai());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getSubUnitKerjaPegawai())) {
			map.setSubUnitKerjaPegawai(mapp.getSubUnitKerjaPegawai());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getAtasanLangsung())) {
			map.setAtasanLangsung(mapp.getAtasanLangsung());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getAtasanLangsungDireksi())) {
			map.setAtasanLangsungDireksi(mapp.getAtasanLangsungDireksi());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getPejabatPenilai())) {
			map.setPejabatPenilai(mapp.getPejabatPenilai());
		}

		if (CommonUtil.isNotNullOrEmpty(mapp.getPejabatPenilaiDireksi())) {
			map.setPejabatPenilaiDireksi(mapp.getPejabatPenilaiDireksi());
		}

		// if (CommonUtil.isNotNullOrEmpty(mapp.getIsPrimary())) {
		// map.setIsPrimary(mapp.getIsPrimary());
		// }

		// if (CommonUtil.isNotNullOrEmpty(mapp.getIsMonitoring())) {
		// map.setIsMonitoring(mapp.getIsMonitoring());
		// }

		// if (CommonUtil.isNotNullOrEmpty(mapp.getIsCanCreateJadwal())) {
		// map.setIsCanCreateJadwal(mapp.getIsCanCreateJadwal());
		// }

		if (CommonUtil.isNotNullOrEmpty(loginUser.getPegawai())) {
			map.setMappingId(mapp.getId());
			map.setPegawaiInput(loginUser.getPegawai());
			map.setTglInput(new Date());
		}
		map = mapPegawaiJabatanToUnitKerjaHistoriDao.save(map);

		result.put("norec", map.getNoRec());

		return result;
	}

	@Transactional(readOnly = false)
	public void disableIsprimary(Integer idPegawai, Integer id) {
		mapPegawaiJabatanToUnitKerjaDao.changeIsNotPrimary(idPegawai, id);
	}

	@Transactional(readOnly = false)
	public void disableIsprimary(Integer idPegawai) {
		mapPegawaiJabatanToUnitKerjaDao.changeIsPrimary(idPegawai);
	}

	@Override
	public Map<String, Object> findAllByPegawai(Integer idPegawai) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", mapPegawaiJabatanToUnitKerjaDao.findAllByPegawai(idPegawai));
		return result;
	}

	@Override
	public List<Map<String, Object>> findAllDetailByPegawai(Integer idPegawai) {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listMapp = mapPegawaiJabatanToUnitKerjaDao.findMappByPegawai(idPegawai);

		for (Map<String, Object> map : listMapp) {
			Map<String, Object> mapFilter = new HashMap<String, Object>();

			Map<String, Object> unitKerja = unitKerjaDao.getUnitKerjaById((Integer) map.get("unitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(unitKerja)) {
				unitKerja = unitKerjaDao.getUnitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> subunitKerja = subUnitKerjaDao
					.getSubunitKerjaById((Integer) map.get("subUnitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(subunitKerja)) {
				subunitKerja = subUnitKerjaDao.getSubunitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> jabatan = jabatanDao.getJabatanById((Integer) map.get("jabatanId"));
			if (CommonUtil.isNullOrEmpty(jabatan)) {
				jabatan = jabatanDao.getJabatanById(Master.EMPTY_DATA);
			}
			Integer jenisJabatanId = jabatanDao.getIdJenisJabatanByJabatan((Integer) map.get("jabatanId"));
			Map<String, Object> jenisJabatan = new HashMap<>();
			if (CommonUtil.isNotNullOrEmpty(jenisJabatanId)) {
				jenisJabatan = jenisJabatanDao.getJenisJabatanById(jenisJabatanId);
				if (CommonUtil.isNullOrEmpty(jenisJabatan)) {
					jenisJabatan = jenisJabatanDao.getJenisJabatanById(Master.EMPTY_DATA);
				}
			}
			Map<String, Object> atasanLangsung = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("atasanLangsungId"));
			if (CommonUtil.isNullOrEmpty(atasanLangsung)) {
				atasanLangsung = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> pejabatPenilai = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("pejabatPenilaiId"));
			if (CommonUtil.isNullOrEmpty(pejabatPenilai)) {
				pejabatPenilai = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> kelompokJabatan = new HashMap<>();
			if (CommonUtil.isNotNullOrEmpty(map.get("gradeId"))) {
				kelompokJabatan = nilaiKelompokJabatanDao
						.getDetailKelompokJabatanById(Integer.valueOf(map.get("gradeId").toString()));
				if (CommonUtil.isNullOrEmpty(kelompokJabatan)) {
					kelompokJabatan = nilaiKelompokJabatanDao.getDetailKelompokJabatanById(Master.EMPTY_DATA);
				}
			} else {
				kelompokJabatan = nilaiKelompokJabatanDao.getDetailKelompokJabatanById(Master.EMPTY_DATA);
			}
			Map<String, Object> sumberData = new HashMap<>();
			if (CommonUtil.isNullOrEmpty(map.get("sumberDataId"))) {
				sumberData.put("id", 0);
				sumberData.put("sumberData", "-");
			} else {
				sumberData.put("id", map.get("sumberDataId"));
				sumberData.put("sumberData", map.get("sumberData"));
			}

			mapFilter.put("id", map.get("id"));
			mapFilter.put("pegawaiId", map.get("pegawaiId"));
			mapFilter.put("atasanLangsungDireksi", map.get("atasanLangsungDireksi"));
			mapFilter.put("pejabatPenilaiDireksi", map.get("pejabatPenilaiDireksi"));
			mapFilter.put("isCanCreateJadwal", map.get("isCanCreateJadwal"));
			mapFilter.put("isPrimary", map.get("isPrimary"));
			mapFilter.put("isMonitoring", map.get("isMonitoring"));
			mapFilter.put("statusEnabled", map.get("statusEnabled"));
			mapFilter.put("unitKerjaPegawai", unitKerja);
			mapFilter.put("subUnitKerjaPegawai", subunitKerja);
			mapFilter.put("jabatan", jabatan);
			mapFilter.put("jenisJabatan", jenisJabatan);
			mapFilter.put("atasanLangsung", atasanLangsung);
			mapFilter.put("pejabatPenilai", pejabatPenilai);
			mapFilter.put("nilaiJabatan", map.get("nilaiJabatan"));
			mapFilter.put("kelompokJabatan", kelompokJabatan);
			if (CommonUtil.isNotNullOrEmpty(kelompokJabatan)) {
				mapFilter.put("grade", kelompokJabatan.get("grade"));
			} else {
				mapFilter.put("grade", "-");
			}
			mapFilter.put("sumberData", sumberData);

			result.add(mapFilter);
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> findAllDetailByLevelJabatan(Integer idPegawai) {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listMapp = new ArrayList<>();

		List<Map<String, Object>> dataUnitKerja = mapPegawaiJabatanToUnitKerjaDao.getMappLevelByPegawai(idPegawai);
		for (Map<String, Object> map : dataUnitKerja) {
			if (map.get("levelJabatan").equals(Master.Jabatan.LEVEL_DIRUT)) {
				listMapp.addAll(mapPegawaiJabatanToUnitKerjaDao.findMappDirutByLevelJabatan(
						Integer.parseInt(map.get("levelJabatan").toString()),
						Arrays.asList(Master.Pegawai.RESTRICTED_EMPLOYEE),
						Arrays.asList(Master.KategoryPegawai.NONSDM)));
			} else if (map.get("levelJabatan").equals(Master.Jabatan.LEVEL_DIREKTUR)) {
				listMapp.addAll(mapPegawaiJabatanToUnitKerjaDao.findMappDirekturByLevelJabatan(
						Integer.parseInt(map.get("levelJabatan").toString()),
						Integer.parseInt(map.get("subLevelJabatan").toString()),
						Arrays.asList(Master.Pegawai.RESTRICTED_EMPLOYEE),
						Arrays.asList(Master.KategoryPegawai.NONSDM)));
			} else if (Arrays.asList(Master.Jabatan.LEVEL_KEPALA).contains(map.get("levelJabatan"))) {
				listMapp.addAll(mapPegawaiJabatanToUnitKerjaDao.findMappByLevelJabatan(
						Integer.parseInt(map.get("idUnit").toString()), idPegawai,
						Arrays.asList(Master.Pegawai.RESTRICTED_EMPLOYEE),
						Arrays.asList(Master.KategoryPegawai.NONSDM)));
			}
		}

		for (Map<String, Object> map : listMapp) {
			Map<String, Object> mapFilter = new HashMap<String, Object>();

			Map<String, Object> unitKerja = unitKerjaDao.getUnitKerjaById((Integer) map.get("unitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(unitKerja)) {
				unitKerja = unitKerjaDao.getUnitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> subunitKerja = subUnitKerjaDao
					.getSubunitKerjaById((Integer) map.get("subUnitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(subunitKerja)) {
				subunitKerja = subUnitKerjaDao.getSubunitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> jabatan = jabatanDao.getJabatanById((Integer) map.get("jabatanId"));
			if (CommonUtil.isNullOrEmpty(jabatan)) {
				jabatan = jabatanDao.getJabatanById(Master.EMPTY_DATA);
			}
			Integer jenisJabatanId = jabatanDao.getIdJenisJabatanByJabatan((Integer) map.get("jabatanId"));
			Map<String, Object> jenisJabatan = new HashMap<>();
			if (CommonUtil.isNotNullOrEmpty(jenisJabatanId)) {
				jenisJabatan = jenisJabatanDao.getJenisJabatanById(jenisJabatanId);
				if (CommonUtil.isNullOrEmpty(jenisJabatan)) {
					jenisJabatan = jenisJabatanDao.getJenisJabatanById(Master.EMPTY_DATA);
				}
			}
			Map<String, Object> pegawai = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("pegawaiId"));
			if (CommonUtil.isNullOrEmpty(pegawai)) {
				pegawai = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> atasanLangsung = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("atasanLangsungId"));
			if (CommonUtil.isNullOrEmpty(atasanLangsung)) {
				atasanLangsung = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> pejabatPenilai = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("pejabatPenilaiId"));
			if (CommonUtil.isNullOrEmpty(pejabatPenilai)) {
				pejabatPenilai = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}

			mapFilter.put("id", map.get("id"));
			mapFilter.put("pegawai", pegawai);
			mapFilter.put("atasanLangsungDireksi", map.get("atasanLangsungDireksi"));
			mapFilter.put("pejabatPenilaiDireksi", map.get("pejabatPenilaiDireksi"));
			mapFilter.put("isCanCreateJadwal", map.get("isCanCreateJadwal"));
			mapFilter.put("isPrimary", map.get("isPrimary"));
			mapFilter.put("isMonitoring", map.get("isMonitoring"));
			mapFilter.put("statusEnabled", map.get("statusEnabled"));
			mapFilter.put("unitKerjaPegawai", unitKerja);
			mapFilter.put("subUnitKerjaPegawai", subunitKerja);
			mapFilter.put("jabatan", jabatan);
			mapFilter.put("jenisJabatan", jenisJabatan);
			mapFilter.put("atasanLangsung", atasanLangsung);
			mapFilter.put("pejabatPenilai", pejabatPenilai);

			result.add(mapFilter);
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> findAllUndefinedDetail() {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listMapp = mapPegawaiJabatanToUnitKerjaDao.findUndefinedMapp(
				Arrays.asList(Master.Pegawai.RESTRICTED_EMPLOYEE), Arrays.asList(Master.KategoryPegawai.NONSDM));

		for (Map<String, Object> map : listMapp) {
			Map<String, Object> mapFilter = new HashMap<String, Object>();

			Map<String, Object> unitKerja = unitKerjaDao.getUnitKerjaById((Integer) map.get("unitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(unitKerja)) {
				unitKerja = unitKerjaDao.getUnitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> subunitKerja = subUnitKerjaDao
					.getSubunitKerjaById((Integer) map.get("subUnitKerjaPegawaiId"));
			if (CommonUtil.isNullOrEmpty(subunitKerja)) {
				subunitKerja = subUnitKerjaDao.getSubunitKerjaById(Master.EMPTY_DATA);
			}
			Map<String, Object> jabatan = jabatanDao.getJabatanById((Integer) map.get("jabatanId"));
			if (CommonUtil.isNullOrEmpty(jabatan)) {
				jabatan = jabatanDao.getJabatanById(Master.EMPTY_DATA);
			}
			Map<String, Object> kategoryPegawai = kategoryPegawaiDao
					.getKategoryPegawaiById((Integer) map.get("kategoryPegawaiId"));
			if (CommonUtil.isNullOrEmpty(kategoryPegawai)) {
				kategoryPegawai = kategoryPegawaiDao.getKategoryPegawaiById(Master.EMPTY_DATA);
			}
			Integer jenisJabatanId = jabatanDao.getIdJenisJabatanByJabatan((Integer) map.get("jabatanId"));
			Map<String, Object> jenisJabatan = new HashMap<>();
			if (CommonUtil.isNotNullOrEmpty(jenisJabatanId)) {
				jenisJabatan = jenisJabatanDao.getJenisJabatanById(jenisJabatanId);
				if (CommonUtil.isNullOrEmpty(jenisJabatan)) {
					jenisJabatan = jenisJabatanDao.getJenisJabatanById(Master.EMPTY_DATA);
				}
			}
			Map<String, Object> pegawai = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("pegawaiId"));
			if (CommonUtil.isNullOrEmpty(pegawai)) {
				pegawai = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> atasanLangsung = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("atasanLangsungId"));
			if (CommonUtil.isNullOrEmpty(atasanLangsung)) {
				atasanLangsung = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}
			Map<String, Object> pejabatPenilai = pegawaiDao.getPegawaiByIdCustom((Integer) map.get("pejabatPenilaiId"));
			if (CommonUtil.isNullOrEmpty(pejabatPenilai)) {
				pejabatPenilai = pegawaiDao.getPegawaiByIdCustom(Master.EMPTY_DATA);
			}

			mapFilter.put("id", map.get("id"));
			mapFilter.put("pegawai", pegawai);
			mapFilter.put("atasanLangsungDireksi", map.get("atasanLangsungDireksi"));
			mapFilter.put("pejabatPenilaiDireksi", map.get("pejabatPenilaiDireksi"));
			mapFilter.put("isCanCreateJadwal", map.get("isCanCreateJadwal"));
			mapFilter.put("isPrimary", map.get("isPrimary"));
			mapFilter.put("isMonitoring", map.get("isMonitoring"));
			mapFilter.put("statusEnabled", map.get("statusEnabled"));
			mapFilter.put("unitKerjaPegawai", unitKerja);
			mapFilter.put("subUnitKerjaPegawai", subunitKerja);
			mapFilter.put("jabatan", jabatan);
			mapFilter.put("jenisJabatan", jenisJabatan);
			mapFilter.put("kategoryPegawai", kategoryPegawai);
			mapFilter.put("atasanLangsung", atasanLangsung);
			mapFilter.put("pejabatPenilai", pejabatPenilai);

			result.add(mapFilter);
		}

		return result;
	}

	@Override
	public Map<String, Object> findSubUnitByUnit(Integer idPegawai, Integer idUnit) {
		Map<String, Object> result = new HashMap<>();
		Pegawai pgw = pegawaiDao.findById(idPegawai);
		List<Map<String, Object>> lis = mapPegawaiJabatanToUnitKerjaDao.findSubUnitByUnit(idPegawai, idUnit);
		if (pgw.getUnitKerja().getUnitKerjaId().equals(idUnit)) {
			Map<String, Object> tmp = new HashMap<>();
			for (Map<String, Object> map : lis) {
				if (map.get("subUnitKerjaPegawaiId").equals(pgw.getUnitKerjaId())) {
					tmp.put("subUnitKerjaPegawaiId", pgw.getUnitKerja().getId());
					tmp.put("nameSubUnitKerjaPegawai", pgw.getUnitKerja().getName());
					break;
				}
			}
			lis.add(tmp);
		}
		result.put("data", lis);
		return result;
	}

	@Override
	public Map<String, Object> findUnitByPgw(Integer id) {
		Map<String, Object> result = new HashMap<>();
		Pegawai pgw = pegawaiDao.findById(id);
		List<Map<String, Object>> lis = mapPegawaiJabatanToUnitKerjaDao.findUnitByPgwId(id);
		Map<String, Object> tmp = new HashMap<>();
		Boolean valid = false;
		for (Map<String, Object> map : lis) {
			if (map.get("unitKerjaPegawaiId").equals(pgw.getUnitKerja().getUnitKerja().getId())) {
				valid = true;
				break;
			}
		}
		if (!valid) {
			tmp.put("unitKerjaPegawaiId", pgw.getUnitKerja().getUnitKerja().getId());
			tmp.put("nameUnitKerjaPegawai", pgw.getUnitKerja().getUnitKerja().getName());
			lis.add(tmp);
		}

		result.put("data", lis);
		return result;
	}

	@Override
	public List<Map<String, Object>> findUnitByPgwJadwal(Integer id) {

		Pegawai pgw = pegawaiDao.findById(id);
		List<Map<String, Object>> lis = mapPegawaiJabatanToUnitKerjaDao.findUnitByPgwId2(id);
		Map<String, Object> tmp = new HashMap<>();
		Boolean valid = false;
		for (Map<String, Object> map : lis) {
			if (map.get("id").equals(pgw.getUnitKerja().getUnitKerja().getId())) {
				valid = true;
				break;
			}
		}
		if (!valid) {
			tmp.put("id", pgw.getUnitKerja().getUnitKerja().getId());
			tmp.put("name", pgw.getUnitKerja().getUnitKerja().getName());
			lis.add(tmp);
		}

		return lis;
	}

	@Override
	public List<Map<String, Object>> findSubUnitByUnitJadwal(Integer idPegawai, Integer idUnit) {
		Integer lvlJabatan = 0;
		List<Map<String, Object>> listLevelJabatanAndMonitoring = mapPegawaiJabatanToUnitKerjaDao
				.getMappLevelJabatanAndMonitoring(idPegawai, idUnit);
		if (CommonUtil.isNotNullOrEmpty(listLevelJabatanAndMonitoring)) {
			for (Map<String, Object> mapLj : listLevelJabatanAndMonitoring) {
				lvlJabatan = Integer.valueOf(mapLj.get("levelJabatan").toString());
				if (lvlJabatan <= 3) {
					break;
				}
			}
		}

		List<Map<String, Object>> lis = new ArrayList<>();
		if (lvlJabatan <= 3) {
			lis = subUnitKerjaDao.getSubUnitKerjaCustomByUnitKerja(idUnit);
		} else {
			lis = mapPegawaiJabatanToUnitKerjaDao.findSubUnitByUnit2(idPegawai, idUnit);
		}

		return lis;
	}

	@Override
	public Map<String, Object> checkAtasan(MapPegawaiJabatanToUnitKerjaVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<MapPegawaiJabatanToUnitKerjaVO> mappVos = new ArrayList<MapPegawaiJabatanToUnitKerjaVO>();
		MapPegawaiJabatanToUnitKerjaVO mappVo = new MapPegawaiJabatanToUnitKerjaVO();

		Map<String, Object> currentDataMappByDetail = mapPegawaiJabatanToUnitKerjaDao.getMappByDetail(
				vo.getJabatan().getId(), vo.getSubUnitKerjaPegawai().getId(), vo.getUnitKerjaPegawai().getId());

		if (CommonUtil.isNotNullOrEmpty(vo.getJabatan().getLevelJabatan())) {
			// hanya jabatan yang memiliki bawahan
			if (CommonUtil.isNotNullOrEmpty(currentDataMappByDetail)) {
				// data mapping existing sudah ada
				if (currentDataMappByDetail.get("id").equals(vo.getId())) {
					// tidak ada perubahan jabatan, unit kerja, subunit kerja

				} else if (!currentDataMappByDetail.get("id").equals(vo.getId())) {
					// ubah atau buat baru jabatan untuk menggantikan pegawai
					// dengan jabatan yang sama sebelumnya

					// delete data pejabat lama
					mappVo.setId((Integer) currentDataMappByDetail.get("id"));
					mappVo.setStatusEnabled(false);
					mappVos.add(mappVo);
					save(mappVos);

					// dapatkan pegawai bawahan
					List<Integer> listPegawai = mapPegawaiJabatanToUnitKerjaDao.getPegawaiBySubunitKerja(
							vo.getSubUnitKerjaPegawai().getId(),
							Integer.valueOf(currentDataMappByDetail.get("levelJabatan").toString()));

					// set atasan di pegawai bawahan
					for (Integer idPeg : listPegawai) {
						List<MappingPegawaiToAtasanVO> vosMappAtasan = new ArrayList<MappingPegawaiToAtasanVO>();
						MappingPegawaiToAtasanVO voMappAtasan = new MappingPegawaiToAtasanVO();
						PegawaiVO voPegawai = new PegawaiVO();
						PegawaiVO voAtasan = new PegawaiVO();
						PegawaiVO voPenilai = new PegawaiVO();

						voPegawai.setId(idPeg);
						voAtasan.setId(vo.getPegawai().getId());
						voPenilai.setId(vo.getPegawai().getId());

						voMappAtasan.setPegawai(voPegawai);
						voMappAtasan.setAtasanLangsung(voAtasan);
						voMappAtasan.setAtasanPejabatPenilai(voPenilai);
						vosMappAtasan.add(voMappAtasan);

						mappingPegawaiToAtasanService.saveMappingPegawaiToAtasan(vosMappAtasan);
					}

				}
			} else { // simpan data mapping baru

			}

		}

		return result;
	}

	@Override
	public void saveHistoryPegawai(MapPegawaiJabatanToUnitKerja model, String perubahan) {
		HistoryDataPegawai historyDataPegawai = new HistoryDataPegawai();
		if (CommonUtil.isNotNullOrEmpty(model)) {
			LoginUser loginUser = loginUserService.getLoginUser();
			model = mapPegawaiJabatanToUnitKerjaDao.findOne(model.getId());
			if (CommonUtil.isNotNullOrEmpty(loginUser.getPegawai())) {
				historyDataPegawai.setPetugas(loginUser.getPegawai());
			}

			MapPegawaiJabatanToUnitKerjaVO data = mapPegawaiJabatanToUnitKerjaConverter.transferModelToVO(model,
					new MapPegawaiJabatanToUnitKerjaVO());

			Gson gson = new Gson();
			String detail = gson.toJson(data);
			if (CommonUtil.isNotNullOrEmpty(detail)) {
				historyDataPegawai.setDetail(detail);
			}

			historyDataPegawai.setPerubahan(perubahan);
			historyDataPegawai.setTanggal(new Date());
			historyDataPegawai.setPegawai(model.getPegawai());
			if (CommonUtil.isNotNullOrEmpty(historyDataPegawai)) {
				historyDataPegawaiDao.save(historyDataPegawai);
			}
		}
	}

	@Override
	public Map<String, Object> getMapJabatanForMonitoringAbsensiByPegawai(Integer idPegawai) {
		Map<String, Object> result = new HashMap<>();

		boolean data = false;
		boolean dataMonitoring = false;

		Integer countMapBuatJadwal = mapPegawaiJabatanToUnitKerjaDao.countBuatJadwalDinasByPegawai(idPegawai);
		if (CommonUtil.isNotNullOrEmpty(countMapBuatJadwal) && countMapBuatJadwal != 0) {
			data = true;
		}
		result.put("data", data);

		Integer countMapMonitoring = mapPegawaiJabatanToUnitKerjaDao.countMonitoringByPegawai(idPegawai);
		if (CommonUtil.isNotNullOrEmpty(countMapMonitoring) && countMapMonitoring != 0) {
			dataMonitoring = true;
		}
		result.put("dataMonitoring", dataMonitoring);

		List<Map<String, Object>> dataSingle = mapPegawaiJabatanToUnitKerjaDao
				.getDataMappingJabatanUtamaByPegawai(idPegawai);
		if (CommonUtil.isNotNullOrEmpty(dataSingle)) {
			result.put("dataSingle", dataSingle);
		} else {
			result.put("dataSingle", new ArrayList<>());
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> getMapUnitKerjaByPegawai(Integer idPegawai) {
		boolean isDirektur = false;

		Integer levelJabatan = 0;
		Integer sublevelJabatan = 0;
		List<Map<String, Object>> mapLevel = mapPegawaiJabatanToUnitKerjaDao.getMappLevelByPegawai(idPegawai);
		for (Map<String, Object> map : mapLevel) {
			if (map.get("levelJabatan").equals(Master.Jabatan.LEVEL_DIREKTUR)) {
				isDirektur = true;
				levelJabatan = Integer.valueOf(map.get("levelJabatan").toString());
				sublevelJabatan = Integer.valueOf(map.get("subLevelJabatan").toString());
				break;
			}
		}

		List<Map<String, Object>> result = mapPegawaiJabatanToUnitKerjaDao.getMapUnitKerjaByPegawai(idPegawai);
		if (isDirektur) {
			result.addAll(mapPegawaiJabatanToUnitKerjaDao.getMapUnitKerjaByLevelJabatan(levelJabatan, sublevelJabatan));
		}

		if (CommonUtil.isNotNullOrEmpty(result)) {
			return result;
		} else {
			return new ArrayList<>();
		}
	}

	@Override
	public List<Map<String, Object>> getMapSubunitKerjaByUnitPegawai(Integer idPegawai, Integer idUnitKerja) {
		Integer lvlJabatan = 0;
		List<Map<String, Object>> listLevelJabatanAndMonitoring = mapPegawaiJabatanToUnitKerjaDao
				.getMappLevelJabatanAndMonitoring(idPegawai, idUnitKerja);
		if (CommonUtil.isNotNullOrEmpty(listLevelJabatanAndMonitoring)) {
			for (Map<String, Object> mapLj : listLevelJabatanAndMonitoring) {
				lvlJabatan = Integer.valueOf(mapLj.get("levelJabatan").toString());
				if (lvlJabatan <= 3) {
					break;
				}
			}
		}

		List<Map<String, Object>> result = new ArrayList<>();
		if (lvlJabatan <= 3) {
			result = subUnitKerjaDao.getSubUnitKerjaCustomByUnitKerja(idUnitKerja);
		} else {
			result = mapPegawaiJabatanToUnitKerjaDao.getMapSubunitKerjaMonitoringByUnitPegawai(idPegawai, idUnitKerja);
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> findAtasanLangsungPegawai(Integer idPegawai) {
		List<Map<String, Object>> result = new ArrayList<>();
		Integer i = 0;

		List<Map<String, Object>> listMap = mapPegawaiJabatanToUnitKerjaDao.getAtasanLangsungByPegawai(idPegawai);
		for (Map<String, Object> map : listMap) {
			Map<String, Object> mapFilter = new HashMap<>();
			if (map.get("idUnitKerja").equals(Master.UnitKerja.DIREKSI)
					&& Arrays.asList(Master.Jabatan.DIRUT).contains(map.get("idJabatan"))) {
				mapFilter.put("id", --i);
				mapFilter.put("namaLengkap", map.get("atasanLangsung"));
			} else {
				mapFilter.put("id", map.get("id"));
				mapFilter.put("namaLengkap", map.get("namaLengkap"));
				mapFilter.put("nipPns", map.get("nipPns"));
			}
			result.add(mapFilter);
		}
		if (CommonUtil.isNotNullOrEmpty(result)) {
			return result;
		} else {
			return new ArrayList<>();
		}
	}

	@Override
	public List<Map<String, Object>> findPejabatPenilaiPegawai(Integer idPegawai) {
		List<Map<String, Object>> result = new ArrayList<>();
		Integer i = 0;

		List<Map<String, Object>> listMap = mapPegawaiJabatanToUnitKerjaDao.getAtasanPejabatPenilaiByPegawai(idPegawai);
		for (Map<String, Object> map : listMap) {
			Map<String, Object> mapFilter = new HashMap<>();
			if (map.get("idUnitKerja").equals(Master.UnitKerja.DIREKSI)) {
				mapFilter.put("id", --i);
				mapFilter.put("namaLengkap", map.get("pejabatPenilai"));
			} else {
				mapFilter.put("id", map.get("id"));
				mapFilter.put("namaLengkap", map.get("namaLengkap"));
				mapFilter.put("nipPns", map.get("nipPns"));
			}
			result.add(mapFilter);
		}
		if (CommonUtil.isNotNullOrEmpty(result)) {
			return result;
		} else {
			return new ArrayList<>();
		}
	}

	@Override
	public Map<String, Object> findAtasanDanUnitKerja(Integer idPegawai, Integer idJabatan) {
		Map<String, Object> result = mapPegawaiJabatanToUnitKerjaDao.getAtasanDanUnitKerjaByPegawai(idPegawai,
				idJabatan);
		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> findAllMap() {
		Map<String, Object> result = new HashMap<>();
		List<MapPegawaiJabatanToUnitKerjaVO> allMappingVo = new ArrayList<>();

		List<MapPegawaiJabatanToUnitKerja> allMapping = mapPegawaiJabatanToUnitKerjaDao.getAllMapping();
		for (MapPegawaiJabatanToUnitKerja model : allMapping) {
			MapPegawaiJabatanToUnitKerjaVO data = mapPegawaiJabatanToUnitKerjaConverter.transferModelToVO(model,
					new MapPegawaiJabatanToUnitKerjaVO());
			allMappingVo.add(data);
		}

		result = saveHistory(allMappingVo);

		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> autoMappingAtasan(Integer idPegawai, Integer idJabatan, Integer idUnit, Integer idSub) {
		Map<String, Object> result = new HashMap<>();

		List<Integer> listPegawaiAtasanHistori = new ArrayList<>();
		List<Integer> listPegawaiPenilaiHistori = new ArrayList<>();

		List<Integer> listAtasan = mapPegawaiJabatanToUnitKerjaDao.listAtasanLangsung();
		List<Integer> listPenilai = mapPegawaiJabatanToUnitKerjaDao.listPejabatPenilai();
		List<Map<String, Object>> mappingBaru = mapPegawaiJabatanToUnitKerjaDao.getMappingJabatanDanAtasan(listAtasan,
				listPenilai, idJabatan, idUnit, idSub);
		if (CommonUtil.isNotNullOrEmpty(mappingBaru)) {
			List<Integer> listAtasanHist = mapPegawaiJabatanToUnitKerjaHistoriDao.getHistoriAtasan(idJabatan, idUnit,
					idSub);
			if (CommonUtil.isNotNullOrEmpty(listAtasanHist)) {
				for (Integer idAtasan : listAtasanHist) {
					listPegawaiAtasanHistori = mapPegawaiJabatanToUnitKerjaHistoriDao.getHistoriBawahanAtasan(idAtasan);
					listPegawaiPenilaiHistori = mapPegawaiJabatanToUnitKerjaHistoriDao
							.getHistoriBawahanPenilai(idAtasan);

					List<Integer> listMappingChanged = new ArrayList<>();
					if (CommonUtil.isNotNullOrEmpty(listPegawaiAtasanHistori)) {
						for (Integer idPegawaiHistori : listPegawaiAtasanHistori) {
							List<Integer> listMapping = mapPegawaiJabatanToUnitKerjaDao
									.getMappingIdByPegawai(idPegawaiHistori);

							Pegawai pegawaiAtasan = new Pegawai();
							pegawaiAtasan.setId(idPegawai);
							for (Integer idMapping : listMapping) {
								MapPegawaiJabatanToUnitKerja mapping = mapPegawaiJabatanToUnitKerjaDao
										.findOne(idMapping);
								if (CommonUtil.isNotNullOrEmpty(mapping)) {
									mapping.setAtasanLangsung(pegawaiAtasan);
									mapPegawaiJabatanToUnitKerjaDao.save(mapping);

									listMappingChanged.add(idMapping);
								}
							}
						}
					}

					if (CommonUtil.isNotNullOrEmpty(listPegawaiPenilaiHistori)) {
						for (Integer idPegawaiHistori : listPegawaiPenilaiHistori) {
							List<Integer> listMapping = mapPegawaiJabatanToUnitKerjaDao
									.getMappingIdByPegawai(idPegawaiHistori);

							Pegawai pegawaiAtasan = new Pegawai();
							pegawaiAtasan.setId(idPegawai);
							for (Integer idMapping : listMapping) {
								MapPegawaiJabatanToUnitKerja mapping = mapPegawaiJabatanToUnitKerjaDao
										.findOne(idMapping);
								if (CommonUtil.isNotNullOrEmpty(mapping)) {
									mapping.setAtasanLangsung(pegawaiAtasan);
									mapPegawaiJabatanToUnitKerjaDao.save(mapping);

									listMappingChanged.add(idMapping);
								}
							}
						}
					}

					result.put("data", listMappingChanged);
				}
			}
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> findFormasiJabatan() {
		List<Map<String, Object>> result = new ArrayList<>();

		List<Integer> listAdmin = new ArrayList<>();
		listAdmin.addAll(Arrays.asList(Master.Pegawai.ADMINISTRATOR));
		listAdmin.addAll(Arrays.asList(Master.Pegawai.LOGIN_ADMIN));

		List<Map<String, Object>> data = mapPegawaiJabatanToUnitKerjaDao.findFormasiJabatan(
				Arrays.asList(Master.KedudukanPegawai.NONSDM), Arrays.asList(Master.KategoryPegawai.NONSDM), listAdmin);

		for (Map<String, Object> map : data) {
			Map<String, Object> jabatan = new HashMap<>();
			Map<String, Object> pegawai = new HashMap<>();
			Map<String, Object> unitKerja = new HashMap<>();
			Map<String, Object> subUnitKerja = new HashMap<>();
			Map<String, Object> kategori = new HashMap<>();
			Map<String, Object> mapResult = new HashMap<>();

			if (CommonUtil.isNotNullOrEmpty(map.get("idJabatan"))) {
				jabatan.put("id", map.get("idJabatan"));
				jabatan.put("namaJabatan", map.get("namaJabatan"));
			}
			pegawai.put("id", map.get("idPegawai"));
			pegawai.put("namaLengkap", map.get("namaLengkap"));
			pegawai.put("nipPns", map.get("nipPns"));
			if (CommonUtil.isNotNullOrEmpty(map.get("idUnitKerja"))) {
				unitKerja.put("id", map.get("idUnitKerja"));
				unitKerja.put("name", map.get("namaUnitKerja"));
			}
			if (CommonUtil.isNotNullOrEmpty(map.get("idSubunitKerja"))) {
				subUnitKerja.put("id", map.get("idSubunitKerja"));
				subUnitKerja.put("name", map.get("namaSubunitKerja"));
			}
			if (CommonUtil.isNotNullOrEmpty(map.get("idKategori"))) {
				kategori.put("id", map.get("idKategori"));
				kategori.put("kategoryPegawai", map.get("namaKategori"));
			}

			mapResult.put("jabatan", jabatan);
			mapResult.put("pegawai", pegawai);
			mapResult.put("unitKerjaPegawai", unitKerja);
			mapResult.put("subUnitKerjaPegawai", subUnitKerja);
			mapResult.put("kategoryPegawai", kategori);

			result.add(mapResult);
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> getJabatanPegawai() {
		List<Map<String, Object>> result = new ArrayList<>();

		LoginUser loginUser = loginUserService.getLoginUser();
		result = mapPegawaiJabatanToUnitKerjaDao.getJabatanPegawai(loginUser.getPegawai().getId());

		return result;
	}

	/**
	 * data evaluasi yang dipakai adalah nilai jabatan tertinggi remunerasi
	 * rangkap jabatan belum terakomodasi secara alur bisnis di sdm
	 */
	@Override
	public Map<String, Object> getEvaluasiJabatanPegawaiBaru(List<Integer> listIdJabatan) {
		Map<String, Object> result = new HashMap<>();

		List<Map<String, Object>> data = mapPegawaiJabatanToUnitKerjaDao
				.findEvaluasiJabatanByAllJabatanPegawaiBaru(listIdJabatan);
		if (CommonUtil.isNotNullOrEmpty(data)) {
			result = data.get(0);
		}

		return result;
	}

	@Override
	public Map<String, Object> getEvaluasiJabatanByPegawai(Integer idPegawai) {
		Map<String, Object> result = new HashMap<>();

		List<Map<String, Object>> data = mapPegawaiJabatanToUnitKerjaDao.findEvaluasiJabatanByPegawai(idPegawai);

		if (CommonUtil.isNotNullOrEmpty(data)) {
			result = data.get(0);
		}

		return result;
	}

	@Override
	public List<Map<String, Object>> findPegawaiByUnitKerja(Integer idUnitKerja, Integer idSubunitKerja) {
		List<Map<String, Object>> result = new ArrayList<>();

		if (CommonUtil.isNullOrEmpty(idUnitKerja) && CommonUtil.isNullOrEmpty(idSubunitKerja)) {
			result = pegawaiDao.findPegawaiByListKategori(Arrays.asList(Master.KategoryPegawai.REMUN));
		} else if (CommonUtil.isNotNullOrEmpty(idUnitKerja) && CommonUtil.isNullOrEmpty(idSubunitKerja)) {
			result = mapPegawaiJabatanToUnitKerjaDao.getPegawaiByUnitKerja(idUnitKerja,
					Arrays.asList(Master.KategoryPegawai.REMUN));
		} else if (CommonUtil.isNotNullOrEmpty(idUnitKerja) && CommonUtil.isNotNullOrEmpty(idSubunitKerja)) {
			result = mapPegawaiJabatanToUnitKerjaDao.getPegawaiByUnitKerja(Arrays.asList(Master.KategoryPegawai.REMUN),
					idSubunitKerja);
		}

		return result;
	}

}
