package com.jasamedika.medifirst2000.service.impl;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.orm.jpa.JpaSystemException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.google.gson.Gson;
import com.jasamedika.medifirst2000.converter.BaseConverterImpl;
import com.jasamedika.medifirst2000.converter.KelompokPasienConverter;
import com.jasamedika.medifirst2000.converter.KonsultasiConverter;
import com.jasamedika.medifirst2000.converter.PasienConverter;
import com.jasamedika.medifirst2000.converter.PasienDaftarConverter;
import com.jasamedika.medifirst2000.converter.PegawaiConverter;
import com.jasamedika.medifirst2000.dao.AlamatDao;
import com.jasamedika.medifirst2000.dao.AntrianPasienDiPeriksaDao;
import com.jasamedika.medifirst2000.dao.AsalRujukanDao;
import com.jasamedika.medifirst2000.dao.AsuransiPasienDao;
import com.jasamedika.medifirst2000.dao.DetailSepDao;
import com.jasamedika.medifirst2000.dao.DiagnosaDao;
import com.jasamedika.medifirst2000.dao.DiagnosaPasienDao;
import com.jasamedika.medifirst2000.dao.DiagnosaTindakanPasienDao;
import com.jasamedika.medifirst2000.dao.DokumenDao;
import com.jasamedika.medifirst2000.dao.HargaNettoProdukByKelasDDao;
import com.jasamedika.medifirst2000.dao.HargaNettoProdukByKelasDao;
import com.jasamedika.medifirst2000.dao.HasilPemeriksaanDao;
import com.jasamedika.medifirst2000.dao.JadwalDokterDao;
import com.jasamedika.medifirst2000.dao.KamarDao;
import com.jasamedika.medifirst2000.dao.KasusPenyakitDao;
import com.jasamedika.medifirst2000.dao.KelasDao;
import com.jasamedika.medifirst2000.dao.KelompokPasienDao;
import com.jasamedika.medifirst2000.dao.KonsultasiDao;
import com.jasamedika.medifirst2000.dao.MappingPasienPacsDao;
import com.jasamedika.medifirst2000.dao.OrderPelayananDao;
import com.jasamedika.medifirst2000.dao.OrderProdukDao;
import com.jasamedika.medifirst2000.dao.PapDataTandaVitalDao;
import com.jasamedika.medifirst2000.dao.PapKeluhanTambahanDao;
import com.jasamedika.medifirst2000.dao.PapKeluhanUtamaDao;
import com.jasamedika.medifirst2000.dao.PapTandaVitalDao;
import com.jasamedika.medifirst2000.dao.PasienDaftarDao;
import com.jasamedika.medifirst2000.dao.PasienDao;
import com.jasamedika.medifirst2000.dao.PasienDiRujukKeIntExtDao;
import com.jasamedika.medifirst2000.dao.PasienInstruksiDao;
import com.jasamedika.medifirst2000.dao.PasienInstruksiPerjanjianDao;
import com.jasamedika.medifirst2000.dao.PegawaiDao;
import com.jasamedika.medifirst2000.dao.PelayananPasienDao;
import com.jasamedika.medifirst2000.dao.PemakaianAsuransiDao;
import com.jasamedika.medifirst2000.dao.PersetujuanUmumDao;
import com.jasamedika.medifirst2000.dao.ProdukDao;
import com.jasamedika.medifirst2000.dao.RegistrasiPelayananPasienDao;
import com.jasamedika.medifirst2000.dao.RuanganDao;
import com.jasamedika.medifirst2000.dao.RunningNumberDao;
import com.jasamedika.medifirst2000.dao.SoapDao;
import com.jasamedika.medifirst2000.dao.StrukHasilPemeriksaanDao;
import com.jasamedika.medifirst2000.dao.StrukKirimDao;
import com.jasamedika.medifirst2000.dao.StrukOrderDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDao;
import com.jasamedika.medifirst2000.dao.StrukReturDao;
import com.jasamedika.medifirst2000.dao.SuratPermintaanMasukDao;
import com.jasamedika.medifirst2000.dao.TempatTidurDao;
import com.jasamedika.medifirst2000.dao.custom.AntrianPasienDiPeriksaDaoCustom;
import com.jasamedika.medifirst2000.dto.AntrianPasienGiziDto;
import com.jasamedika.medifirst2000.dto.RuanganJumlah;
import com.jasamedika.medifirst2000.entities.Agama;
import com.jasamedika.medifirst2000.entities.Alamat;
import com.jasamedika.medifirst2000.entities.AntrianPasienDiPeriksa;
import com.jasamedika.medifirst2000.entities.AsalRujukan;
import com.jasamedika.medifirst2000.entities.AsuransiPasien;
import com.jasamedika.medifirst2000.entities.DesaKelurahan;
import com.jasamedika.medifirst2000.entities.DetailDiagnosaPasien;
import com.jasamedika.medifirst2000.entities.DetailKamar;
import com.jasamedika.medifirst2000.entities.DetailSep;
import com.jasamedika.medifirst2000.entities.Diagnosa;
import com.jasamedika.medifirst2000.entities.DiagnosaPasien;
import com.jasamedika.medifirst2000.entities.Dokumen;
import com.jasamedika.medifirst2000.entities.GolonganAsuransi;
import com.jasamedika.medifirst2000.entities.HargaNettoProdukByKelasD;
import com.jasamedika.medifirst2000.entities.HasilPemeriksaan;
import com.jasamedika.medifirst2000.entities.HubunganPesertaAsuransi;
import com.jasamedika.medifirst2000.entities.JadwalDokter;
import com.jasamedika.medifirst2000.entities.JenisDokumen;
import com.jasamedika.medifirst2000.entities.JenisKelamin;
import com.jasamedika.medifirst2000.entities.JenisProduk;
import com.jasamedika.medifirst2000.entities.Kamar;
import com.jasamedika.medifirst2000.entities.KasusPenyakit;
import com.jasamedika.medifirst2000.entities.Kebangsaan;
import com.jasamedika.medifirst2000.entities.Kecamatan;
import com.jasamedika.medifirst2000.entities.Kelas;
import com.jasamedika.medifirst2000.entities.KelompokPasien;
import com.jasamedika.medifirst2000.entities.KelompokTransaksi;
import com.jasamedika.medifirst2000.entities.KendaliDokumenRekamMedis;
import com.jasamedika.medifirst2000.entities.Konsultasi;
import com.jasamedika.medifirst2000.entities.KotaKabupaten;
import com.jasamedika.medifirst2000.entities.MappingPasienPacs;
import com.jasamedika.medifirst2000.entities.Negara;
import com.jasamedika.medifirst2000.entities.OrderPelayanan;
import com.jasamedika.medifirst2000.entities.OrderProduk;
import com.jasamedika.medifirst2000.entities.PapDataTandaVital;
import com.jasamedika.medifirst2000.entities.PapKeluhanUtama;
import com.jasamedika.medifirst2000.entities.PapTandaVital;
import com.jasamedika.medifirst2000.entities.Pasien;
import com.jasamedika.medifirst2000.entities.PasienDaftar;
import com.jasamedika.medifirst2000.entities.PasienDiRujukKeIntExt;
import com.jasamedika.medifirst2000.entities.PasienInstruksiPerjanjian;
import com.jasamedika.medifirst2000.entities.PasienInstruksiPerjanjianT;
import com.jasamedika.medifirst2000.entities.Pegawai;
import com.jasamedika.medifirst2000.entities.Pekerjaan;
import com.jasamedika.medifirst2000.entities.PelayananPasien;
import com.jasamedika.medifirst2000.entities.PelayananPasienDetail;
import com.jasamedika.medifirst2000.entities.PemakaianAsuransi;
import com.jasamedika.medifirst2000.entities.Pendidikan;
import com.jasamedika.medifirst2000.entities.Produk;
import com.jasamedika.medifirst2000.entities.ProdukDetailLaboratorium;
import com.jasamedika.medifirst2000.entities.ProdukDetailLaboratoriumNilaiNormal;
import com.jasamedika.medifirst2000.entities.Propinsi;
import com.jasamedika.medifirst2000.entities.RegistrasiPelayananPasien;
import com.jasamedika.medifirst2000.entities.Rekanan;
import com.jasamedika.medifirst2000.entities.Ruangan;
import com.jasamedika.medifirst2000.entities.RunningNumber;
import com.jasamedika.medifirst2000.entities.Soap;
import com.jasamedika.medifirst2000.entities.StatusBed;
import com.jasamedika.medifirst2000.entities.StatusKeluar;
import com.jasamedika.medifirst2000.entities.StatusPerkawinan;
import com.jasamedika.medifirst2000.entities.StrukHasilPemeriksaan;
import com.jasamedika.medifirst2000.entities.StrukKirim;
import com.jasamedika.medifirst2000.entities.StrukOrder;
import com.jasamedika.medifirst2000.entities.StrukPelayanan;
import com.jasamedika.medifirst2000.entities.StrukRetur;
import com.jasamedika.medifirst2000.entities.SuratPermintaanMasuk;
import com.jasamedika.medifirst2000.entities.TempatTidur;
import com.jasamedika.medifirst2000.enums.StatusAntrianEnum;
import com.jasamedika.medifirst2000.enums.StatusPenyakitEnum;
import com.jasamedika.medifirst2000.enums.TipePasienEnum;
import com.jasamedika.medifirst2000.exception.ServiceVOException;
import com.jasamedika.medifirst2000.service.AdmisiRencanaPindahRuanganService;
import com.jasamedika.medifirst2000.service.AntrianPasienDiPeriksaService;
import com.jasamedika.medifirst2000.service.BridgingBpjs;
import com.jasamedika.medifirst2000.service.DiagnosaPasienService;
import com.jasamedika.medifirst2000.service.DokumenRekamMedisService;
import com.jasamedika.medifirst2000.service.KendaliDokumenRekamMedisService;
import com.jasamedika.medifirst2000.service.LoginUserService;
import com.jasamedika.medifirst2000.service.MasukKamarService;
import com.jasamedika.medifirst2000.service.PasienDaftarService;
import com.jasamedika.medifirst2000.service.RegistrasiPasienService;
import com.jasamedika.medifirst2000.service.RegistrasiPelayananService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.DateUtil;
import com.jasamedika.medifirst2000.util.HibernateInitialize;
import com.jasamedika.medifirst2000.util.JsonUtil;
import com.jasamedika.medifirst2000.util.StringUtil;
import com.jasamedika.medifirst2000.vo.AdmisiRencanaPindahRuanganVO;
import com.jasamedika.medifirst2000.vo.AgamaVO;
import com.jasamedika.medifirst2000.vo.AsalRujukanVO;
import com.jasamedika.medifirst2000.vo.AsuransiPasienVO;
import com.jasamedika.medifirst2000.vo.AsuransiRegistrasiPasienVO;
import com.jasamedika.medifirst2000.vo.DesaKelurahanVO;
import com.jasamedika.medifirst2000.vo.DetailKamarVO;
import com.jasamedika.medifirst2000.vo.DiagnosaVO;
import com.jasamedika.medifirst2000.vo.DokumenRekamMedisVO;
import com.jasamedika.medifirst2000.vo.DokumenVO;
import com.jasamedika.medifirst2000.vo.GolonganAsuransiVO;
import com.jasamedika.medifirst2000.vo.GridAntrianPasienDiPeriksaVO;
import com.jasamedika.medifirst2000.vo.HubunganPesertaAsuransiVO;
import com.jasamedika.medifirst2000.vo.JenisKelaminVO;
import com.jasamedika.medifirst2000.vo.KamarVO;
import com.jasamedika.medifirst2000.vo.KasusPenyakitVO;
import com.jasamedika.medifirst2000.vo.KebangsaanVO;
import com.jasamedika.medifirst2000.vo.KecamatanVO;
import com.jasamedika.medifirst2000.vo.KelasVO;
import com.jasamedika.medifirst2000.vo.KelompokPasienVO;
import com.jasamedika.medifirst2000.vo.KonsultasiVO;
import com.jasamedika.medifirst2000.vo.KotaKabupatenVO;
import com.jasamedika.medifirst2000.vo.MasukKamarVO;
import com.jasamedika.medifirst2000.vo.NegaraVO;
import com.jasamedika.medifirst2000.vo.OrderProdukVO;
import com.jasamedika.medifirst2000.vo.PasienDaftarVO;
import com.jasamedika.medifirst2000.vo.PasienVO;
import com.jasamedika.medifirst2000.vo.PegawaiVO;
import com.jasamedika.medifirst2000.vo.PekerjaanVO;
import com.jasamedika.medifirst2000.vo.PemakaianAsuransiVO;
import com.jasamedika.medifirst2000.vo.PendidikanVO;
import com.jasamedika.medifirst2000.vo.ProdukVO;
import com.jasamedika.medifirst2000.vo.PropinsiVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPasienPenunjangVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPasienVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPelayananPasienVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPelayananVO;
import com.jasamedika.medifirst2000.vo.RekananVO;
import com.jasamedika.medifirst2000.vo.RuanganVO;
import com.jasamedika.medifirst2000.vo.StatusKeluarVO;
import com.jasamedika.medifirst2000.vo.StatusPerkawinanVO;
import com.jasamedika.medifirst2000.vo.StrukKirimVO;
import com.jasamedika.medifirst2000.vo.StrukOrderVO;
import com.jasamedika.medifirst2000.vo.StrukReturVO;
import com.jasamedika.medifirst2000.vo.TempatTidurVO;

/**
 * Implement class for RegistrasiPasienService
 * 
 * @author Askur
 * @param <T>
 */
@Service("registrasiPelayananService")
public class RegistrasiPelayananServiceImpl extends BaseVoServiceImpl
		implements RegistrasiPelayananService<RegistrasiPelayananVO> {

	@Autowired
	private PasienDao pasienDao;

	@Autowired
	private DetailSepDao detailSepDao;

	@Autowired
	private DiagnosaDao diagnosaDao;

	@Autowired
	private StrukPelayananDao strukPelayananDao;

	@Autowired
	private HargaNettoProdukByKelasDDao hargaNettoProdukByKelasDDao;

	@Autowired
	private HargaNettoProdukByKelasDao hargaNettoProdukByKelasDao;

	@Autowired
	private PasienDaftarDao pasienDaftarDao;
	@Autowired
	private KelompokPasienDao kelompokPasienDao;
	@Autowired
	private PersetujuanUmumDao persetujuanUmumDao;

	@Autowired
	private PasienDaftarConverter pasienDaftarConverterTest;

	@Autowired
	private RegistrasiPelayananPasienDao registrasiPelayananPasienDao;

	@Autowired
	private SuratPermintaanMasukDao suratPermintaanMasukDao;

	@Autowired
	private PasienInstruksiDao pasienInstruksiDao;

	@Autowired
	private BaseConverterImpl<KasusPenyakitVO, KasusPenyakit> kasusPenyakitConverter;

	@Autowired
	private BaseConverterImpl<PasienDaftarVO, PasienDaftar> pasienDaftarCustomConverter;
	@Autowired
	private PasienConverter pasienConverter;

	@Autowired
	private RegistrasiPasienService registrasiPasienService;

	@Autowired
	private BridgingBpjs bridgingBpjs;

	@Autowired
	private BaseConverterImpl<AsalRujukanVO, AsalRujukan> asalRujukanConverter;

	@Autowired
	private BaseConverterImpl<RuanganVO, Ruangan> ruanganConverter;

	@Autowired
	private BaseConverterImpl<RegistrasiPelayananPasienVO, RegistrasiPelayananPasien> registrasiPelayananPasienConverter;

	@Autowired
	private PegawaiConverter pegawaiConverter;

	@Autowired
	private PegawaiDao pegawaiDao;

	@Autowired
	private KelompokPasienConverter kelompokPasienConverter;

	@Autowired
	private BaseConverterImpl<StrukOrderVO, StrukOrder> strukOrderConverter;

	@Autowired
	private PasienDaftarService pasienDaftarService;

	@Autowired
	private JadwalDokterDao jadwalDokterDao;

	@Autowired
	private BaseConverterImpl<PasienDaftarVO, PasienDaftar> pasienDaftarConverter;

	@Autowired
	private BaseConverterImpl<RekananVO, Rekanan> rekananConverter;

	@Autowired
	private AntrianPasienDiPeriksaService antrianPasienDiPeriksaService;

	@Autowired
	private AntrianPasienDiPeriksaDao antrianPasienDiPeriksaDao;
	@Autowired
	private OrderPelayananDao orderPelayananDao;

	@Autowired
	private AntrianPasienDiPeriksaDaoCustom antrianPasienDiPeriksaDaoCustom;

	@Autowired
	private RuanganDao ruanganDao;

	@Autowired
	private KelasDao kelasDao;

	@Autowired
	private SoapDao soapDao;

	@Autowired
	private DiagnosaPasienService diagnosaPasienService;

	@Autowired
	private PasienInstruksiPerjanjianDao pasienInstruksiPerjanjianDao;

	@Autowired
	private KonsultasiDao konsultasiDao;

	@Autowired
	private KonsultasiConverter konsultasiConverter;

	@Autowired
	private PasienDiRujukKeIntExtDao pasienDiRujukKeIntExtDao;

	@Autowired
	private AsuransiPasienDao asuransiPasienDao;

	@Autowired
	private BaseConverterImpl<AsuransiPasienVO, AsuransiPasien> asuransiPasienConverter;

	@Autowired
	private BaseConverterImpl<GolonganAsuransiVO, GolonganAsuransi> golonganAsuransiConverter;

	@Autowired
	private BaseConverterImpl<HubunganPesertaAsuransiVO, HubunganPesertaAsuransi> hubunganPesertaAsuransiConverter;

	@Autowired
	private BaseConverterImpl<PemakaianAsuransiVO, PemakaianAsuransi> pemakaianAsuransiConverter;

	@Autowired
	private BaseConverterImpl<DiagnosaVO, Diagnosa> diagnosaConverter;

	@Autowired
	private MasukKamarService masukKamarService;

	@Autowired
	private BaseConverterImpl<KamarVO, Kamar> kamarConverter;

	@Override
	public RegistrasiPelayananVO update(RegistrasiPelayananVO vo) throws JpaSystemException, ServiceVOException {
		return null;
	}

	@Override
	public Boolean delete(Integer key) throws JpaSystemException {
		return null;
	}

	@Override
	public RegistrasiPelayananVO findById(Integer key) throws JpaSystemException {
		return null;
	}

	@Override
	public List<RegistrasiPelayananVO> findAll() throws JpaSystemException {
		return null;
	}

	@Override
	public Map<String, Object> findAllWithPageAndLimitAndSortByAndDirectionParameter(Integer page, Integer limit,
			String sort, String dir) {
		return null;
	}

	@Autowired
	private MappingPasienPacsDao mappingPasienPacsDao;

	@Override
	@Transactional
	// @Caching(cacheable = {
	// @Cacheable(value="testFindCache")
	// })

	public Map<String, Object> findAllAntrianPaging(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Map<String, Object> mapResult = null;

		/*
		 * Date startDate = null; Date endDate = null; if
		 * (CommonUtil.isNotNullOrEmpty(dateStart)) { startDate =
		 * DateUtil.toDate(dateStart); } if
		 * (CommonUtil.isNotNullOrEmpty(dateEnd)) { endDate =
		 * DateUtil.toDate(dateEnd); }
		 */

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingList(rowStart, rowEnd, convertDate(dateStart), convertDate(dateEnd), ruanganId,
						noCm, pegawaiId);

		if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksaList)) {

			Boolean isRadiologi = ruanganId != null;
			if (isRadiologi == true)
				isRadiologi = ruanganId == 35;
			List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
			for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
				GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
				gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
				gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
						gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
								antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
								new String[] { "namaPasien", "noCm", "jenisKelamin" }));
					}
				}
				if (isRadiologi) {
					MappingPasienPacs mapping = mappingPasienPacsDao
							.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
					if (mapping != null) {
						gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
						gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
					}
				}
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
					gridAntrianPasienDiPeriksaVO
							.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
									new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
					gridAntrianPasienDiPeriksaVO.setKelas(kelasConverter.transferModelToVO(
							JsonUtil.initializeAndUnproxy(antrianPasienDiPeriksa.getKelas()), new KelasVO()));
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
					gridAntrianPasienDiPeriksaVO
							.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasien())) {
						if (CommonUtil.isNotNullOrEmpty(
								antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin())) {
							gridAntrianPasienDiPeriksaVO.setJenisKelamin(antrianPasienDiPeriksa.getPasienDaftar()
									.getPasien().getJenisKelamin().getJenisKelamin());
						}
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien())) {
						if (CommonUtil.isNotNullOrEmpty(
								antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien())) {
							gridAntrianPasienDiPeriksaVO.setKelompokPasien(
									antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());
						}
					}
				}

				if (antrianPasienDiPeriksa.getStrukOrder() != null) {
					try {
						Map<String, Object> strukOrder = new HashMap<>();
						strukOrder.put("noRec", antrianPasienDiPeriksa.getStrukOrder().getNoRec());
						// add by iwankasan
						// add noBedah show on listdataantrian pasien
						// 27.10.2017
						strukOrder.put("noBedah", antrianPasienDiPeriksa.getStrukOrder().getNoOrderIntern());

						gridAntrianPasienDiPeriksaVO.setStrukOrder(strukOrder);
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
					PasienDaftarVO pasienDaftarVO = new PasienDaftarVO();
					pasienDaftarVO.setNoRec(antrianPasienDiPeriksa.getPasienDaftar().getNoRec());
					pasienDaftarVO.setNoRegistrasi(antrianPasienDiPeriksa.getPasienDaftar().getNoRegistrasi());
					pasienDaftarVO.setTglRegistrasi(antrianPasienDiPeriksa.getPasienDaftar().getTglRegistrasi());
					gridAntrianPasienDiPeriksaVO.setPasienDaftar(pasienDaftarVO);
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
					gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
							.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
					if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
						gridAntrianPasienDiPeriksaVO
								.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
					} else if (antrianPasienDiPeriksa.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
						gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
					}
				} else {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
					gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
				}

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
					Ruangan r = ruanganDao.findOne(antrianPasienDiPeriksa.getRuangan().getId());
					if (CommonUtil.isNotNullOrEmpty(r.getHeadRuangan())) {
						Ruangan ruanganParent = ruanganDao.findOne(r.getHeadRuangan().getId());
						gridAntrianPasienDiPeriksaVO.setRuangan(ruanganConverter.transferModelToVOCustom(ruanganParent,
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
					} else {
						gridAntrianPasienDiPeriksaVO.setRuangan(
								ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
										new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
					}
				}
				gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);
			}
			mapResult = constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
		} else {
			mapResult = null;
		}
		return mapResult;
	}

	// add by Arya 2016-01-03
	@Override
	@Transactional
	public Map<String, Object> findAllAntrianPasienGiziPaging(Integer ruanganId, String namaRuangan, String dateStart,
			String dateEnd, String noCm, Integer pegawaiId) {

		Map<String, Object> result = new HashMap<String, Object>();

		try {
			System.out.println("==================START GET ALL ANTRIAN PASIEN GIZI======================");

			List<AntrianPasienGiziDto> dtoList = new ArrayList<AntrianPasienGiziDto>();
			List<Map<String, Object>> resultMap = antrianPasienDiPeriksaDaoCustom.getAllAntrianPasienGizi(dateStart,
					dateEnd, ruanganId, namaRuangan, noCm, pegawaiId);
			for (int i = 0; i < resultMap.size(); i++) {
				AntrianPasienGiziDto dto = new AntrianPasienGiziDto();
				dto.setNoRec(resultMap.get(i).get("noRec").toString());
				dto.setNoCm(resultMap.get(i).get("noCm").toString());
				dto.setPasienId(Integer.parseInt(resultMap.get(i).get("pasienId").toString()));
				dto.setNamaPasien(resultMap.get(i).get("namaPasien").toString());
				dto.setTglLahir(DateUtil.toDate(resultMap.get(i).get("tglLahir").toString()));
				dto.setTglRegistrasi(DateUtil.toDate(resultMap.get(i).get("tglRegistrasi").toString()));
				dto.setRuanganId(Integer.parseInt(resultMap.get(i).get("ruanganId").toString()));
				dto.setNamaRuangan(resultMap.get(i).get("namaRuangan").toString());
				dto.setPegawaiId(Integer.parseInt(resultMap.get(i).get("pegawaiId").toString()));
				dto.setNamaPegawai(resultMap.get(i).get("namaLengkap").toString());
				dto.setStatusAntrian(resultMap.get(i).get("statusAntrian").toString());

				dto.setListDiagnosa(new ArrayList<Map<String, Object>>());
				dto.setListAlergi(new ArrayList<Map<String, Object>>());
				dto.setListJenisDiet(new ArrayList<Map<String, Object>>());

				if (CommonUtil.isNotNullOrEmpty(dto.getStatusAntrian())) {
					if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
					} else if (dto.getStatusAntrian()
							.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
					} else if (dto.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
						dto.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
					} else {
						dto.setStatusAntrian("");
					}
				} else {
					dto.setStatusAntrian("UNDIFINED");
				}

				// get Diagnosa
				List<Map<String, Object>> listDiagnosa = antrianPasienDiPeriksaDao.findDiagnosa(dto.getNoRec());
				for (Map<String, Object> list : listDiagnosa) {
					Map<String, Object> dataDiagnosa = new HashMap<String, Object>();
					dataDiagnosa.put("diagnosaId", list.get("diagnosaId").toString());
					dataDiagnosa.put("namaDiagnosa", list.get("namaDiagnosa").toString());
					dto.getListDiagnosa().add(dataDiagnosa);
				}
				// get Alergi
				List<Map<String, Object>> listAlergi = antrianPasienDiPeriksaDao.findAlergi(dto.getNoRec());
				for (Map<String, Object> list : listAlergi) {
					Map<String, Object> dataAlergi = new HashMap<String, Object>();
					dataAlergi.put("alergiId", list.get("alergiId").toString());
					dataAlergi.put("namaAlergi", list.get("namaAlergi").toString());
					dto.getListAlergi().add(dataAlergi);
				}
				// get Jenis Diet
				List<Map<String, Object>> listJenisDiet = antrianPasienDiPeriksaDao.findJenisDiet(dto.getNoRec());
				for (Map<String, Object> list : listJenisDiet) {
					Map<String, Object> dataJenisDiet = new HashMap<String, Object>();
					dataJenisDiet.put("jenisDietId", list.get("jenisDietId").toString());
					dataJenisDiet.put("jenisDiet", list.get("jenisDiet").toString());
					dto.getListJenisDiet().add(dataJenisDiet);
				}
				dtoList.add(dto);
			}
			result.put("result", dtoList);
			System.out.println("==================END GET ALL ANTRIAN PASIEN GIZI======================");
		} catch (Exception e) {
			e.printStackTrace();
		}

		return result;
	}
	// end add by Arya 2016-01-03

	@Override
	public RegistrasiPelayananVO add(RegistrasiPelayananVO vo) throws JpaSystemException, ServiceVOException {
		return null;
	}

	@Autowired
	private PemakaianAsuransiDao pemakaianAsuransiDao;

	@Autowired
	private DokumenDao dokumenDao;

	@Autowired
	private DokumenRekamMedisService dokumenRekamMedisService;

	@Autowired
	private BaseConverterImpl<StatusKeluarVO, StatusKeluar> statusKeluarConverter;

	@Override
	public Map<String, Object> getPasienDaftar(Date start, Date until) {
		Map<String, Object> maps = new HashMap<>();
		try {
			List<Map<String, Object>> data = JsonUtil.ToMaps(pasienDaftarDao.findByPasienPulang(start, until));
			for (Map<String, Object> map : data) {
				Map<String, Object> kelompokPasien = (Map<String, Object>) map.get("kelompokPasien");
				if ((int) kelompokPasien.get("id") == 2) {
					PemakaianAsuransi pem = pemakaianAsuransiDao
							.findByPasienDaftarPasienDaftarNoRec((String) map.get("noRec"));
					if (pem != null)
						map.put("pemakaianAsuransi", pem.ToMap());
				}
			}
			maps.put("pasienPulang", data);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return maps;
	}

	@Autowired
	private AdmisiRencanaPindahRuanganService admisiRencanaPindahRuanganService;
	@Autowired
	private BaseConverterImpl<TempatTidurVO, TempatTidur> tempatTidurConverter;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePasienDafar(RegistrasiPelayananVO vo) {
		Map<String, Object> result = new HashMap<>();

		if (CommonUtil.isNotNullOrEmpty(vo.getStatus())) {
			PasienDaftar pasienDaftar = pasienDaftarDao.findOne(vo.getNoRecPasienDaftar());
			String instalasiGawatDarurat = pelayananPasienDao.getSettingDataFixed("KdDepartemenInstalasiGawatDarurat");
			AdmisiRencanaPindahRuanganVO admisiRencanaPindahRuanganVO = vo.getAdmisiRencanaPindahRuangan();
			if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
				Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());
				if (ruangan.getDepartemenId() == Integer.valueOf(instalasiGawatDarurat)) {
					pasienDaftar.setTglPulang(null);
				}
				Map<String, Object> check = admisiRencanaPindahRuanganService
						.update(vo.getAdmisiRencanaPindahRuangan());
				if (CommonUtil.isNotNullOrEmpty(check)) {
					RegistrasiPelayananPasien registrasiPelayananPasien = new RegistrasiPelayananPasien();

					if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
						registrasiPelayananPasien.setPasienDaftar(pasienDaftar);
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
						registrasiPelayananPasien.setAsalRujukan(
								asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKasusPenyakit())) {
						registrasiPelayananPasien.setKasusPenyakit(
								kasusPenyakitConverter.transferVOToModel(vo.getKasusPenyakit(), new KasusPenyakit()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
						registrasiPelayananPasien.setKdDokter(vo.getPegawai().getNoRec());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKelompokPasien())) {
						registrasiPelayananPasien.setKelompokPasien(kelompokPasienConverter
								.transferVOToModel(vo.getKelompokPasien(), new KelompokPasien()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
						registrasiPelayananPasien
								.setPasien(pasienConverter.transferVOToModel(vo.getPasien(), new Pasien()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getTglRegistrasi())) {
						registrasiPelayananPasien.setTglMasuk(vo.getTglRegistrasi());
					}

					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getKelasRencana())) {
						registrasiPelayananPasien.setKelas(kelasConverter
								.transferVOToModel(admisiRencanaPindahRuanganVO.getKelasRencana(), new Kelas()));
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getRuanganRencana())) {
						registrasiPelayananPasien.setRuangan(ruanganConverter
								.transferVOToModel(admisiRencanaPindahRuanganVO.getRuanganRencana(), new Ruangan()));
						pasienDaftar.setRuangan(ruanganConverter
								.transferVOToModel(admisiRencanaPindahRuanganVO.getRuanganRencana(), new Ruangan()));
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getStatusKeluarRencana())) {
						registrasiPelayananPasien.setStatusKeluar(statusKeluarConverter.transferVOToModel(
								admisiRencanaPindahRuanganVO.getStatusKeluarRencana(), new StatusKeluar()));
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getNoBedRencana())) {
						registrasiPelayananPasien.setNoBed(admisiRencanaPindahRuanganVO.getNoBedRencana().byteValue());
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getKelasKamarRencana())) {
						registrasiPelayananPasien.setKamar(kamarConverter
								.transferVOToModel(admisiRencanaPindahRuanganVO.getKelasKamarRencana(), new Kamar()));
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getTempatTidur())) {
						registrasiPelayananPasien.setTempatTidur(tempatTidurConverter
								.transferVOToModel(admisiRencanaPindahRuanganVO.getTempatTidur(), new TempatTidur()));
					}
					if (CommonUtil.isNotNullOrEmpty(admisiRencanaPindahRuanganVO.getKeteranganLainya())) {
						registrasiPelayananPasien
								.setKeteranganLainnyaRencana(admisiRencanaPindahRuanganVO.getKeteranganLainya());
					}

					if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
						registrasiPelayananPasienDao.save(registrasiPelayananPasien);
					}
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
						PasienDaftar passienDaftarResult = pasienDaftarDao.save(pasienDaftar);
						result.put("noRec", passienDaftarResult.getNoRec());
						// added akomodasi to pelayanan pasien and pelayanan
						// pasien detail -->added by susy
						AntrianPasienDiPeriksa antrianPasienDiPeriksa = antrianPasienDiPeriksaDao
								.findOne(vo.getNoRecAntrianPasien());
						/*if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
							Map<String, Object> pelayananPasien = saveAkomodasi(antrianPasienDiPeriksa,
									vo.getRawatGabung(), true, false);
							if (CommonUtil.isNotNullOrEmpty(pelayananPasien)) {
								result.putAll(pelayananPasien);
							}
						}*/
					}
				}
			}
		} else {
			if (CommonUtil.isNotNullOrEmpty(vo)) {
				String statusPasien = "";

				String KdDepartemenInstalasiRawatJalan = pelayananPasienDao
						.getSettingDataFixed("KdDepartemenInstalasiRawatJalan");

				String KdDepartemenInstalasiPeristi = pelayananPasienDao
						.getSettingDataFixed("KdDepartemenInstalasiPeristi");

				String KdDepartemenInstalasiRehabilitasiMedik = pelayananPasienDao
						.getSettingDataFixed("KdDepartemenInstalasiRehabilitasiMedik");

				String KdDepartemenInstalasiGawatDarurat = pelayananPasienDao
						.getSettingDataFixed("KdDepartemenInstalasiGawatDarurat");

				String KdDepartemenInstalasiRawatInap = pelayananPasienDao
						.getSettingDataFixed("KdDepartemenInstalasiRawatInap");

				String KdInstalasiICU = pelayananPasienDao.getSettingDataFixed("KdInstalasiICU");

				Kelas nonKelas = kelasDao.findNonKelas();
				AntrianPasienDiPeriksa antrianPasienDiPeriksa = null;

				Integer instalasiRawatJalan = Integer.parseInt(KdDepartemenInstalasiRawatJalan);
				Integer instalasiRehabilitasiMedik = Integer.parseInt(KdDepartemenInstalasiRehabilitasiMedik);
				Integer instalasiGawatDarurat = Integer.parseInt(KdDepartemenInstalasiGawatDarurat);
				Integer instalasiRawatInap = Integer.parseInt(KdDepartemenInstalasiRawatInap);
				Integer instalasiPeristi = Integer.parseInt(KdDepartemenInstalasiPeristi);
				Integer instalasiICU = Integer.parseInt(KdInstalasiICU);
				// ------------------------------------------------------------------------------------------------

				// Cari pasien jika di catatan belum bayar
				if (CommonUtil.isNotNullOrEmpty(pelayananPasienDao.strukPelayanan(vo.getPasien().getId()))) {
					// statusPasien = "Pasien belum menyelesaikan administrasi";

					// Pasien bisa daftar dengan catatan
				} else {

					// Cari pasien daftar pada hari yang sama ada
					List<Map<String, Object>> pasiens = pelayananPasienDao.tglDaftarInToDay(vo.getPasien().getId(),
							vo.getTglRegistrasi());

					Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());

					// Jika pasien daftar pada hari yang sama ada
					if (CommonUtil.isNotNullOrEmpty(pasiens)) {

						for (Map<String, Object> pasien : pasiens) {
							boolean ada = false;

							// Jika ruangan pasien ketika daftar sama pada hari
							// yang sama
							if (((Integer) pasien.get("ruanganId") == ruangan.getId())) {
								if (CommonUtil.isNotNullOrEmpty(pasien.get("dokterId"))
										&& CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
									if (((Integer) pasien.get("dokterId") == vo.getPegawai().getId())) {
										statusPasien = "Pasien sudah terdaftar";
										ada = true;
										break;
									}
								}

							}
							// Jika ruangan pasien ketika daftar berbeda pada
							// hari yang sama
							if (!ada) {
								// Cari jika pasien belum pulang di RI & ICU
								if (ruangan.getDepartemenId() == instalasiRawatInap
										|| ruangan.getDepartemenId() == instalasiICU
										|| ruangan.getDepartemenId() == instalasiPeristi) {
									for (Map<String, Object> data : pasienDaftarDao.checkPasienPulang(
											vo.getPasien().getPasienDaftar().getNoRec(), instalasiRawatInap)) {
										if (CommonUtil.isNullOrEmpty(data.get("tglPulang"))) {
											statusPasien = "Pasien belum dipulangkan";
											break;
										}
									}
									for (Map<String, Object> data : pasienDaftarDao.checkPasienPulang(
											vo.getPasien().getPasienDaftar().getNoRec(), instalasiPeristi)) {
										if (CommonUtil.isNullOrEmpty(data.get("tglPulang"))) {
											statusPasien = "Pasien belum dipulangkan";
											break;
										}
									}

									// True jika pasien daftar pada hari yang
									// sama di lain ruangan
								} else {
									statusPasien = "";
								}
							}
						}

						// Jika pasien daftar di hari yang berbeda
					} else {

						// Cari pasien yang belum pulang di RI & ICU
						if (ruangan.getDepartemenId() == instalasiRawatInap || ruangan.getDepartemenId() == instalasiICU
								|| ruangan.getDepartemenId() == instalasiPeristi) {
							for (Map<String, Object> data : pasienDaftarDao.checkPasienPulang(
									vo.getPasien().getPasienDaftar().getNoRec(), instalasiRawatInap)) {
								if (CommonUtil.isNullOrEmpty(data.get("tglPulang"))) {
									statusPasien = "Pasien belum dipulangkan";
									break;
								}
							}
							for (Map<String, Object> data : pasienDaftarDao
									.checkPasienPulang(vo.getPasien().getPasienDaftar().getNoRec(), instalasiPeristi)) {
								if (CommonUtil.isNullOrEmpty(data.get("tglPulang"))) {
									statusPasien = "Pasien belum dipulangkan";
									break;
								}
							}

							// True jika pasien daftar pada hari lain di rawat
							// jalan
						} else {
							statusPasien = "";
						}
					}
				}
				//
				List<Map<String, Object>> pasienbelumPulang = pelayananPasienDao
						.PasienbelumPulang(vo.getPasien().getId());
				if (CommonUtil.isNotNullOrEmpty(pasienbelumPulang)) {
					statusPasien = "Pasien belum dipulangkan";
				}
				// CheckPasienPerjanjian
				Map<String, Object> pasienPerjanjian = new HashMap<String, Object>();
				if (vo.getRuangan().getDepartemenId() == instalasiRehabilitasiMedik) {
					pasienPerjanjian = checkPasienPerjanjian(vo.getPasien().getId(), vo.getRuangan().getId());
					statusPasien = pasienPerjanjian.get("status") + "";
				}
				// ------------------------------------------------------------------------------------------------

				if (CommonUtil.isNullOrEmpty(statusPasien)) {

					PasienDaftar pasienDaftar = new PasienDaftar();

					if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
						pasienDaftar.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getJenisPelayanan())) {
						pasienDaftar.setJenisPelayanan(vo.getJenisPelayanan());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						Integer hitungBilik = ruanganDao.countRuanganBilik(vo.getRuangan().getId());
						if (hitungBilik == 0) {
							pasienDaftar.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
							pasienDaftar
									.setRuanganAsal(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
						} else {
							Ruangan r = findRuanganBilik(vo.getRuangan().getId(), vo.getTglRegistrasi());
							pasienDaftar.setRuangan(r);
							pasienDaftar.setRuanganAsal(r);
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
							if (vo.getRuangan().getDepartemenId() == instalasiRawatJalan
									|| vo.getRuangan().getDepartemenId() == instalasiRehabilitasiMedik
									|| vo.getRuangan().getDepartemenId() == instalasiGawatDarurat) {

								pasienDaftar.setTglPulang(DateUtil.now());
								pasienDaftar.setKelas(nonKelas);
							} else if (vo.getRuangan().getDepartemenId() == instalasiRawatInap
									|| vo.getRuangan().getDepartemenId() == instalasiPeristi
									|| vo.getRuangan().getDepartemenId() == instalasiICU) {
								if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
									pasienDaftar.setTglPulang(null);
									pasienDaftar.setKelas(
											BaseConverterImpl.transferVOToModelData(vo.getKelas(), new Kelas()));
								}
							}
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKasusPenyakit())) {
						pasienDaftar.setKasusPenyakit(
								kasusPenyakitConverter.transferVOToModel(vo.getKasusPenyakit(), new KasusPenyakit()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
						pasienDaftar.setPasien(pasienConverter.transferVOToModel(vo.getPasien(), new Pasien()));

						if (CommonUtil.isNotNullOrEmpty(vo.getPasien().getId())) {
							if (pasienDaftarService.checkStatusPasien(vo.getPasien().getId())) {
								pasienDaftar.setStatusPasien(TipePasienEnum.LAMA.getVal());
							} else {
								pasienDaftar.setStatusPasien(TipePasienEnum.BARU.getVal());
							}
						} else {
							pasienDaftar.setStatusPasien(TipePasienEnum.BARU.getVal());
						}

						List<PasienDaftar> listPasienDaftar = pasienDaftarDao
								.findByPasienNoCm(vo.getPasien().getNoCm());
						if (listPasienDaftar == null) {
							pasienDaftar.setIsKajianAwal(true);
						} else {
							if (listPasienDaftar.size() == 0) {
								pasienDaftar.setIsKajianAwal(true);
							} else {
								PasienDaftar pasienDaftarTemp = listPasienDaftar.get(0);
								long diff = new Date().getTime() - pasienDaftarTemp.getTglRegistrasi().getTime();
								long diffMonth = diff / 1000 / 60 / 60 / 24 / 30;
								pasienDaftar.setIsKajianAwal(diffMonth >= 3);
							}
						}
						KasusPenyakit kasusPenyakit = new KasusPenyakit();
						kasusPenyakit.setId(1);
						pasienDaftar.setKasusPenyakit(kasusPenyakit);

						Integer countKasusPenyakit = pasienDaftarDao
								.checkStatuspasien(pasienDaftar.getKasusPenyakit().getId());
						if (countKasusPenyakit == 0 || countKasusPenyakit == null) {
							pasienDaftar.setStatusKasusPenyakit(true);
						} else {
							pasienDaftar.setStatusKasusPenyakit(false);
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKelompokPasien())) {
						pasienDaftar.setKelompokPasien(kelompokPasienConverter.transferVOToModel(vo.getKelompokPasien(),
								new KelompokPasien()));
					} else {
						pasienDaftar.setKelompokPasien(kelompokPasienDao.defaultKelompokPasien());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsOnSiteService())) {
						pasienDaftar.setIsOnSiteService(vo.getIsOnSiteService());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getIsRegistrasiLengkap())) {
						pasienDaftar.setIsRegistrasiLengkap(vo.getIsRegistrasiLengkap());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getTglRegistrasi())) {
						pasienDaftar.setTglRegistrasi(vo.getTglRegistrasi());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
						pasienDaftar.setDokterPenanggungJawab(
								pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getEmergensi())) {
						pasienDaftar.setEmergensi(vo.getEmergensi());
					}

					Set<AntrianPasienDiPeriksa> antrianPasienDiPeriksaSet = new HashSet<>();
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
						antrianPasienDiPeriksa = new AntrianPasienDiPeriksa();
						antrianPasienDiPeriksa.setStatusPasien((byte) 1);

						if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
							antrianPasienDiPeriksa
									.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
							if (CommonUtil.isNotNullOrEmpty(vo.getPasien().getId())) {
								if (antrianPasienDiPeriksaService.checkStatusPasien(vo.getPasien().getId(),
										vo.getRuangan().getId())) {
									antrianPasienDiPeriksa.setStatusKunjungan(TipePasienEnum.LAMA.getVal());
								} else {
									antrianPasienDiPeriksa.setStatusKunjungan(TipePasienEnum.BARU.getVal());
									Ruangan ruanganRehabMedik = ruanganDao.findRuanganRehabilitasiMedik();
									if (CommonUtil.isNotNullOrEmpty(vo.getRuangan().getId())
											&& ruanganRehabMedik != null) {
										if (vo.getRuangan().getId() == ruanganRehabMedik.getId()) {
											antrianPasienDiPeriksa
													.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal());
										}
									}
								}

							}

							Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());
							if (ruangan.getDepartemenId() == instalasiRawatInap
									|| ruangan.getDepartemenId() == instalasiICU
									|| ruangan.getDepartemenId() == instalasiPeristi) {
								if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
									antrianPasienDiPeriksa
											.setKelas(kelasConverter.transferVOToModel(vo.getKelas(), new Kelas()));
								}
								if (CommonUtil.isNotNullOrEmpty(vo.getKamar())) {
									antrianPasienDiPeriksa
											.setKamar(kamarConverter.transferVOToModel(vo.getKamar(), new Kamar()));
								}
								if (CommonUtil.isNotNullOrEmpty(vo.getRawatGabung())) {
									antrianPasienDiPeriksa.setIsRawatGabung(vo.getRawatGabung());
								}
								if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
									if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur().getNomorBed())) {
										antrianPasienDiPeriksa
												.setNoBed(Integer.valueOf(vo.getNomorTempatTidur().getNomorBed()));
									}
								}
								if (CommonUtil.isNotNullOrEmpty(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
									antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.getVal());
								}
							} else {
								if (CommonUtil.isNotNullOrEmpty(nonKelas)) {
									antrianPasienDiPeriksa.setKelas(nonKelas);
								}
								if (CommonUtil.isNotNullOrEmpty(StatusAntrianEnum.MENUNGGU.getVal())) {
									antrianPasienDiPeriksa.setNoMasuk(StatusAntrianEnum.MENUNGGU.getVal());
									antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MENUNGGU.getVal());
								}
							}
						}

						if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
							antrianPasienDiPeriksa.setAsalRujukan(
									asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
							antrianPasienDiPeriksa
									.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
							antrianPasienDiPeriksa.setNoAntrian(antrianPasienDiPeriksaService
									.getFormatNumberByMonthYearBilik(pasienDaftar.getRuangan().getId()));
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
							antrianPasienDiPeriksa.setPasienDaftar(pasienDaftar);
						}
						if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
							antrianPasienDiPeriksa.setTglMasuk(new Date());
							antrianPasienDiPeriksaSet.add(antrianPasienDiPeriksa);
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getTglRegistrasi())) {
							antrianPasienDiPeriksa.setTglRegistrasi(vo.getTglRegistrasi());
							String noRegistrasi = pasienDaftarService
									.getFormatNumberByMonthYearByParameter(vo.getTglRegistrasi());
							pasienDaftar.setNoRegistrasi(noRegistrasi);
						}
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksaSet)) {
						pasienDaftar.setAntrianPasienDiPeriksaSet(antrianPasienDiPeriksaSet);
					}

					/*
					 * ------------------SAVE PASIEN DAFTAR------------------
					 */

					PasienDaftar passienDaftarResult = pasienDaftarDao.save(pasienDaftar);

					if (CommonUtil.isNotNullOrEmpty(passienDaftarResult)) {
						result.put("noRec", pasienDaftar.getNoRec());
						result.put("noRecAntrian", antrianPasienDiPeriksa.getNoRec());
						result.put("noRegistrasi", pasienDaftar.getNoRegistrasi());
						result.put("noAntrian", antrianPasienDiPeriksa.getNoAntrian());
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
							result.put("noCm", pasienDaftar.getPasien().getNoCm());
						}

						if (passienDaftarResult.getRuangan().getDepartemenId() == instalasiRawatInap
								|| passienDaftarResult.getRuangan().getDepartemenId() == instalasiICU
								|| passienDaftarResult.getRuangan().getDepartemenId() == instalasiPeristi) {

							RegistrasiPelayananPasien registrasiPelayananPasien = new RegistrasiPelayananPasien();
							registrasiPelayananPasien.setPasienDaftar(pasienDaftar);
							Integer kamarId = 0;
							if (CommonUtil.isNotNullOrEmpty(vo.getKamar())) {
								Kamar kamar = kamarDao.findOne(vo.getKamar().getId());
								kamarId = kamar.getId();
								if (CommonUtil.isNotNullOrEmpty(kamar)) {
									registrasiPelayananPasien.setKamar(kamar);
									Integer jumlahKamarIsi = kamar.getJumlaKamarIsi() + 1;
									if (CommonUtil.isNotNullOrEmpty(jumlahKamarIsi)) {
										kamar.setJumlaKamarIsi(jumlahKamarIsi);
									}
									Integer jumlahKamarKosong = kamar.getJumlaKamarKosong() - 1;
									if (CommonUtil.isNotNullOrEmpty(jumlahKamarKosong)) {
										kamar.setJumlaKamarKosong(jumlahKamarKosong);
									}
									if ((CommonUtil.isNotNullOrEmpty(kamar)) && vo.getRawatGabung().FALSE) {
										kamarDao.save(kamar);
									}
								}
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
								TempatTidur tempatTidur = tempatTidurDao.findOne(vo.getNomorTempatTidur().getId());
								registrasiPelayananPasien.setTempatTidur(tempatTidur);
								StatusBed statusBed = new StatusBed();
								statusBed.setId(1);

								if (CommonUtil.isNotNullOrEmpty(statusBed)) {
									tempatTidur.setStatusBed(statusBed);
								}
								if (CommonUtil.isNotNullOrEmpty(tempatTidur) && vo.getRawatGabung().FALSE) {
									tempatTidurDao.save(tempatTidur);
								}
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
								registrasiPelayananPasien.setAsalRujukan(
										asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKasusPenyakit())) {
								registrasiPelayananPasien.setKasusPenyakit(pasienDaftar.getKasusPenyakit());
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
								registrasiPelayananPasien.setKdDokter(vo.getPegawai().getNoRec());
							}
							// edited by susy
							if (CommonUtil.isNotNullOrEmpty(pasienPerjanjian)) {
								registrasiPelayananPasien
										.setKodeNomorBuktiPerjanjian(pasienPerjanjian.get("noRec") + "");
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKelas())) {
								registrasiPelayananPasien.setKelas(pasienDaftar.getKelas());
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKelompokPasien())) {
								registrasiPelayananPasien.setKelompokPasien(pasienDaftar.getKelompokPasien());
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
								registrasiPelayananPasien.setRuangan(pasienDaftar.getRuangan());
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
								registrasiPelayananPasien.setPasien(pasienDaftar.getPasien());
							}
							if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getTglRegistrasi())) {
								registrasiPelayananPasien.setTglMasuk(pasienDaftar.getTglRegistrasi());
							}
							if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
								registrasiPelayananPasienDao.save(registrasiPelayananPasien);
							}
							// added akomodasi to pelayanan pasien and pelayanan
							// pasien detail -->added by susy
							/*Map<String, Object> pelayananPasien = saveAkomodasi(antrianPasienDiPeriksa,
									vo.getRawatGabung(), false, false);
							if (CommonUtil.isNotNullOrEmpty(pelayananPasien)) {
								result.putAll(pelayananPasien);
							}*/
						}
						Dokumen dokumenResult = null;
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
							Dokumen dokumen = pasienDaftar.getPasien().getDokumenRekamMedis();

							if (CommonUtil.isNullOrEmpty(dokumen)) {
								dokumen = new Dokumen();

								if (CommonUtil.isNullOrEmpty(dokumen.getTglDokumen())) {
									dokumen.setTglDokumen(new Date());
								}
								if (CommonUtil.isNullOrEmpty(dokumen.getqDokumen())) {
									dokumen.setqDokumen(0);
								}
								if (CommonUtil.isNullOrEmpty(dokumen.getJenisDokumen())) {
									JenisDokumen jenisDokumen = new JenisDokumen();
									jenisDokumen.setId(0);
									dokumen.setJenisDokumen(jenisDokumen);
								}
								if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien().getNoCm())) {
									dokumen.setDeskripsiDokumen(
											"Dokumen Rekam medis untuk pasien " + pasienDaftar.getPasien().getNoCm());
									dokumen.setNamaJudulDokumen("RM-" + pasienDaftar.getPasien().getNoCm());
									dokumen.setReportDisplay("RM-" + pasienDaftar.getPasien().getNoCm());
								}
								if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
									dokumen.setRuangan(pasienDaftar.getRuangan());
								}
								if (CommonUtil.isNotNullOrEmpty(dokumen)) {
									dokumenResult = dokumenDao.save(dokumen);

									if (CommonUtil.isNotNullOrEmpty(dokumenResult.getId())) {
										Pasien pasien = pasienDao.findOne(pasienDaftar.getPasien().getId());

										if (CommonUtil.isNotNullOrEmpty(dokumenResult)) {
											pasien.setDokumenRekamMedis(dokumenResult);
										}
										if (CommonUtil.isNotNullOrEmpty(pasien)) {
											pasienDao.save(pasien);
										}
									}
								}
							} else {
								dokumen.setRuangan(pasienDaftar.getRuangan());
								dokumenResult = dokumenDao.save(dokumen);
							}
						}

						if (CommonUtil.isNotNullOrEmpty(dokumenResult)) {
							StrukKirim strukKirim = new StrukKirim();

							String noKirim = "DRM" + getRunningNumber("KRIM");
							Pegawai pegawai = loginUserService.getLoginUser().getPegawai();
							Ruangan ruanganAsal = null;

							if (CommonUtil.isNotNullOrEmpty(noKirim)) {
								strukKirim.setNokirim(noKirim);
								strukKirim.setNokirim_intern(noKirim);
								strukKirim.setTglkirim(new Date());
								strukKirim.setQtydetailjenisproduk(0.0);
								strukKirim.setQtyproduk(0.0);
								strukKirim.setTotalbeamaterai(0.0);
								strukKirim.setTotalhargasatuan(0.0);
								strukKirim.setTotalbiayakirim(0.0);
								strukKirim.setTotalbiayatambahan(0.0);
								strukKirim.setTotaldiscount(0.0);
								strukKirim.setTotalharusdibayar(0.0);
								strukKirim.setTotalpph(0.0);
								strukKirim.setTotalppn(0.0);
								strukKirim.setKeteranganlainnyakirim("Pengiriman dokumen rekammedis");
								KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
								kelompokTransaksi.setId(
										Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiDokumenRekamMedis")));
								strukKirim.setKelompokTransaksi(kelompokTransaksi);

								if (CommonUtil.isNotNullOrEmpty(pegawai)) {
									strukKirim.setPegawaiPengirim(pegawai);
								}
								if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
									strukKirim.setKdruangantujuan(
											ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
								}
								if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
									ruanganAsal = ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan());
									ruanganAsal.setId(Integer.parseInt(GetSettingDataFixed("KdRuanganRekamMedis")));
									strukKirim.setKdruanganasal(ruanganAsal);
									strukKirim.setKdruangan(ruanganAsal);
								}
								if (CommonUtil.isNotNullOrEmpty(strukKirim)) {
									StrukKirim strukKirimREsult = strukKirimDao.save(strukKirim);

									if (CommonUtil.isNotNullOrEmpty(strukKirimREsult)) {
										DokumenRekamMedisVO dokumenRekamMedis = new DokumenRekamMedisVO();

										if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
											dokumenRekamMedis.setNoCM(vo.getPasien());
											dokumenRekamMedis.setStatusEnabled(true);
											dokumenRekamMedis.setStatus("Belum diterima ruangan tujuan");
										}
										if (CommonUtil.isNotNullOrEmpty(dokumenResult.getId())) {
											DokumenVO dokumenVo = new DokumenVO();
											dokumenVo.setId(dokumenResult.getId());
											dokumenRekamMedis.setNoDokumen(dokumenVo);
										}
										if (CommonUtil.isNotNullOrEmpty(dokumenRekamMedis)) {
											dokumenRekamMedis.setNoKirim(strukKirimConverter
													.transferModelToVO(strukKirimREsult, new StrukKirimVO()));
										}
										if (CommonUtil.isNotNullOrEmpty(ruanganAsal)) {
											dokumenRekamMedis.setRuanganAsal(
													ruanganConverter.transferModelToVO(ruanganAsal, new RuanganVO()));
										}
										if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
											dokumenRekamMedis.setRuanganTujuan(vo.getRuangan());
										}

										dokumenRekamMedis.setNoRecPasienDaftar(passienDaftarResult.getNoRec());

										if (CommonUtil.isNotNullOrEmpty(dokumenRekamMedis.getNoCM())) {
											dokumenRekamMedisService.saveDokumenRekamMedis(dokumenRekamMedis);
										}
									}
								}
							}
						}
					}
					String noreg = secondCheckNoRegistrasi(passienDaftarResult);
					if (!noreg.equals("")) {
						result.put("noRegistrasi", noreg);
					}
				} else {
					result.put("statusPasien", statusPasien);
				}
			}
		}
		return result;
	}

	@Autowired
	private RunningNumberDao runningNumberDao;

	@Autowired
	private StrukKirimDao strukKirimDao;

	@Transactional(readOnly = false)
	private String getRunningNumber(String kegunaan) {
		RunningNumber runningNumber = runningNumberDao.findByResetAndKegunaan("0", kegunaan);

		Integer number = (runningNumber.getNomerTerbaru() + (Integer) 1);
		runningNumber.setNomerTerbaru(runningNumber.getNomerTerbaru() + (Integer) 1);
		String noOrderIntern = StringUtil.formatNumber(number.toString(), 6);
		runningNumberDao.save(runningNumber);
		return noOrderIntern;
	}

	@Autowired
	private LoginUserService loginUserService;
	@Autowired
	private BaseConverterImpl<StrukKirimVO, StrukKirim> strukKirimConverter;

	@Override
	public Map<String, Object> updatStatusAntrian(String noRegistrasi, String statusAntrian, String tglDipanggilSuster,
			String tglDipanggilDokter) {
		Map<String, Object> result = new HashMap<String, Object>();

		AntrianPasienDiPeriksa antrianPasienDiPeriksa = antrianPasienDiPeriksaDao.findOne(noRegistrasi);

		if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
			if (noRegistrasi.length() != 10)
				antrianPasienDiPeriksa = antrianPasienDiPeriksaDao.findByNoRec(noRegistrasi);
			try {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
					antrianPasienDiPeriksa.setStatusAntrian(statusAntrian);

					SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					if (CommonUtil.isNotNullOrEmpty(tglDipanggilSuster)) {
						// Date tanggalDipanggilSuster = formatter.parse(new
						// Date());
						antrianPasienDiPeriksa.setTglDipanggilSuster(new Date());
					}
					if (CommonUtil.isNotNullOrEmpty(tglDipanggilDokter)) {
						Date tanggalDipanggilDokter = formatter.parse(tglDipanggilDokter);
						antrianPasienDiPeriksa.setTglDipanggilDokter(tanggalDipanggilDokter);
					}
					antrianPasienDiPeriksaDao.save(antrianPasienDiPeriksa);
					result.put("dataFound", true);
				} else {
					result.put("dataFound", false);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePasienDaftarPenunjang(RegistrasiPasienPenunjangVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();

		PasienDaftar pasienDaftar = new PasienDaftar();

		if (CommonUtil.isNotNullOrEmpty(vo)) {
			result = registrasiPasienService.saveRegistrasiPasien((RegistrasiPasienVO) vo);
			// ---------------------------------------------------------------------
			pasienDaftar.setPasien(pasienConverter.transferVOToModel(vo.getPasien(), new Pasien()));
			pasienDaftar.setStatusKasusPenyakit(false);
			pasienDaftar.setIsOnSiteService(Byte.parseByte("0"));
			pasienDaftar.setIsRegistrasiLengkap(Byte.parseByte("0"));
			pasienDaftar.setTglRegistrasi(new Date());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
			pasienDaftar.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
			List<PasienDaftar> listPasienDaftar = pasienDaftarDao.findByPasienNoCm((String) result.get("noCm"));

			if (CommonUtil.isNullOrEmpty(listPasienDaftar)) {
				pasienDaftar.setIsKajianAwal(true);
			} else {
				PasienDaftar pasienDaftarTemp = listPasienDaftar.get(0);
				long diff = new Date().getTime() - pasienDaftarTemp.getTglRegistrasi().getTime();
				long diffMonth = diff / 1000 / 60 / 60 / 24 / 30;
				pasienDaftar.setIsKajianAwal(diffMonth >= 3);
			}
			// ---------------------------------------------------------------------
			if (CommonUtil.isNotNullOrEmpty(vo.getPasien().getId())) {
				if (pasienDaftarService.checkStatusPasien(vo.getPasien().getId())) {
					pasienDaftar.setStatusPasien(TipePasienEnum.LAMA.getVal());
				} else {
					pasienDaftar.setStatusPasien(TipePasienEnum.BARU.getVal());
				}
			} else {
				pasienDaftar.setStatusPasien(TipePasienEnum.BARU.getVal());
			}
			// ---------------------------------------------------------------------
		}
		Integer kelompokPasienId = Integer.parseInt(GetSettingDataFixed("KdKelompokPasienUmum").toString());
		if (CommonUtil.isNotNullOrEmpty(kelompokPasienId)) {
			KelompokPasien kelompokPasien = new KelompokPasien();
			kelompokPasien.setId(kelompokPasienId);
			pasienDaftar.setKelompokPasien(kelompokPasien);
		}
		Kelas kelas = kelasDao.findNonKelas();
		if (CommonUtil.isNotNullOrEmpty(kelas)) {
			pasienDaftar.setKelas(kelas);
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
			pasienDaftar.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
			pasienDaftar.setPasien(pasienConverter.transferVOToModel(vo.getPasien(), new Pasien()));
		}
		Pegawai pegawai = pegawaiDao.findOne(Integer.parseInt(GetSettingDataFixed("KdPegawaiPJLaboratorium")));
		if (CommonUtil.isNotNullOrEmpty(pegawai)) {
			pasienDaftar.setDokterPenanggungJawab(pegawai);
		}
		String noRegistrasi = pasienDaftarService.getFormatNumberByMonthYear();
		if (CommonUtil.isNotNullOrEmpty(noRegistrasi)) {
			pasienDaftar.setNoRegistrasi(pasienDaftarService.getFormatNumberByMonthYear());
		}
		// ---------------------------------------------------------------------
		AntrianPasienDiPeriksa antrianPasienDiPeriksa = new AntrianPasienDiPeriksa();
		if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
			antrianPasienDiPeriksa.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
			antrianPasienDiPeriksa
					.setAsalRujukan(asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
			antrianPasienDiPeriksa.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));

			if (CommonUtil.isNotNullOrEmpty(vo.getPasien().getId())) {
				if (antrianPasienDiPeriksaService.checkStatusPasien(vo.getPasien().getId(), vo.getRuangan().getId())) {
					antrianPasienDiPeriksa.setStatusKunjungan(TipePasienEnum.LAMA.getVal());
				} else {
					antrianPasienDiPeriksa.setStatusKunjungan(TipePasienEnum.BARU.getVal());
				}

				if (diagnosaPasienService.checkDiagnosaPasien(vo.getPasien().getId())) {
					antrianPasienDiPeriksa.setStatusPenyakit(StatusPenyakitEnum.LAMA.getVal());
				} else {
					antrianPasienDiPeriksa.setStatusPenyakit(StatusPenyakitEnum.BARU.getVal());
				}
			}
		}

		antrianPasienDiPeriksa.setTglRegistrasi(new Date());
		antrianPasienDiPeriksa.setNoMasuk(StatusAntrianEnum.MENUNGGU.getVal());
		antrianPasienDiPeriksa.setStatusPasien((byte) 1);
		antrianPasienDiPeriksa.setPasienDaftar(pasienDaftar);
		antrianPasienDiPeriksa.setNoAntrian(antrianPasienDiPeriksaService.getFormatNumberByMonthYear());
		antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MENUNGGU.getVal());
		pasienDaftar.getAntrianPasienDiPeriksaSet().add(antrianPasienDiPeriksa);

		PasienDaftar passienDaftarResult = pasienDaftarDao.save(pasienDaftar);
		if (CommonUtil.isNotNullOrEmpty(passienDaftarResult)) {
			result.put("noRec", antrianPasienDiPeriksa.getNoRec());
			result.put("noRegistrasi", pasienDaftar.getNoRegistrasi());
			result.put("noAntrian", antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
				result.put("noCm", pasienDaftar.getPasien().getNoCm());
			}
		}
		return result;
	}

	@Autowired
	private DiagnosaPasienDao diagnosaPasienDao;

	@Autowired
	private DiagnosaTindakanPasienDao diagnosaPasienTindakanDao;

	@Override
	@Transactional
	public List<Map<String, Object>> findPealyananRawatJalan(Short kdProfile, String noCm) {
		List<PasienDaftar> temp = pasienDaftarDao.findPelayananRawatJalan(kdProfile, noCm);
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		for (PasienDaftar item : temp) {

			for (AntrianPasienDiPeriksa map : antrianPasienDiPeriksaDao
					.findByNoRegisterNonRawatInap(item.getNoRegistrasi())) {
				AntrianPasienDiPeriksa antrian = map;
				Map<String, Object> data = new HashMap<String, Object>();
				data.put("tanggal", map.getTglRegistrasi());
				try {
					data.put("diagnosa",
							JsonUtil.ToMaps(diagnosaPasienDao.findDiagnosaPasienByNoCmAndTglInput(
									antrian.getPasienDaftar().getPasien().getNoCm(),
									antrian.getPasienDaftar().getTglRegistrasi())));
					data.put("tindakan",
							JsonUtil.ToMaps(diagnosaPasienTindakanDao.findDiagnosaTindakanPasienByNoCmAndTglInput(
									antrian.getPasienDaftar().getPasien().getNoCm(),
									antrian.getPasienDaftar().getTglRegistrasi())));
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
				data.put("laboratorium", new ArrayList<>());
				data.put("radiologi", "");
				data.put("konsultasi", new ArrayList<>());

				data.put("kasusPenyakit", antrian.getStatusPenyakit());
				data.put("obat", new ArrayList<>());
				if (antrian.getPegawai() != null)
					data.put("dokterPananggungJawab", antrian.getPegawai().getNamaLengkap());
				else
					data.put("dokterPananggungJawab", "");
				data.put("display", new SimpleDateFormat("dd MMM").format(item.getTglRegistrasi()));
				PasienDaftar pasienDaftar = antrian.getPasienDaftar();

				data.put("isKajianAwal", pasienDaftar.getIsKajianAwal());
				data.put("noRec", antrian.getNoRec());
				list.add(data);
			}

		}
		return list;
	}

	@Override
	public Map<String, Object> findBpjsAntrianPaging(Integer page, Integer limit, String sort, String dir,
			String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
			endDate.setHours(23);
			endDate.setMinutes(59);
			endDate.setSeconds(59);
		}

		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findBpjsAntrianPagingList(0, rowEnd, startDate, endDate, noCm, pegawaiId);

		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm" }));
				}
			}

			gridAntrianPasienDiPeriksaVO
					.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
							new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			gridAntrianPasienDiPeriksaVO.setPasienDaftar(
					pasienDaftarConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getPasienDaftar(),
							new PasienDaftarVO(), new String[] { "id", "noRegistrasi", "tglRegistrasi", "noRec" }));

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}
			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, 0, 0);
	}

	@Autowired
	private PapKeluhanUtamaDao papKeluhanUtamaDao;
	@Autowired
	private PapKeluhanTambahanDao papKeluhanTamnbahanDao;
	@Autowired
	private PapDataTandaVitalDao papDataTandaVitalDao;
	@Autowired
	private PapTandaVitalDao papTandaVitalDao;
	@Autowired
	private KamarDao kamarDao;
	@Autowired
	private TempatTidurDao tempatTidurDao;
	@Autowired
	private AlamatDao alamatDao;
	@Autowired
	private StrukReturDao strukReturDao;
	@Autowired
	private BaseConverterImpl<StrukReturVO, StrukRetur> strukReturConverter;

	@Override
	public Map<String, Object> findPasienDaftarById(String noRec) {
		Map<String, Object> result = new HashMap<>();
		try {
			if (CommonUtil.isNotNullOrEmpty(noRec)) {
				AntrianPasienDiPeriksa antrianPasienDiPeriksa = antrianPasienDiPeriksaDao.findOne(noRec);

				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {

					PasienDaftar pasienDaftar = antrianPasienDiPeriksa.getPasienDaftar();

					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoRec())) {
						result.put("noRec", antrianPasienDiPeriksa.getNoRec());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
						result.put("kelas", antrianPasienDiPeriksa.getKelas().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStrukOrder())) {
						// result.put("strukOrder",
						// antrianPasienDiPeriksa.getStrukOrder().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
						result.put("asalRujukan", antrianPasienDiPeriksa.getAsalRujukan().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusKunjungan())) {
						result.put("statusKunjungan", antrianPasienDiPeriksa.getStatusKunjungan());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusPenyakit())) {
						result.put("statusPenyakit", antrianPasienDiPeriksa.getStatusPenyakit());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
						result.put("pegawai", antrianPasienDiPeriksa.getPegawai().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStrukRetur())) {
						result.put("strukRetur", antrianPasienDiPeriksa.getStrukRetur());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKamar())) {
						result.put("kamar", antrianPasienDiPeriksa.getKamar().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKasusPenyakit())) {
						result.put("kasusPenyakit", antrianPasienDiPeriksa.getKasusPenyakit().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoAntrian())) {
						result.put("noAntrian", antrianPasienDiPeriksa.getNoAntrian());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoBed())) {
						result.put("noBed", antrianPasienDiPeriksa.getNoBed());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
						result.put("pasienDaftar", antrianPasienDiPeriksa.getPasienDaftar().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPrefixNoAntrian())) {
						result.put("prefixNoAntrian", antrianPasienDiPeriksa.getPrefixNoAntrian());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getTglRegistrasi())) {
						result.put("tglRegistrasi", antrianPasienDiPeriksa.getTglRegistrasi());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getTglDipanggilSuster())) {
						result.put("tglDipanggilSuster", antrianPasienDiPeriksa.getTglDipanggilSuster());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getTglDipanggilDokter())) {
						result.put("tglDipanggilDokter", antrianPasienDiPeriksa.getTglDipanggilDokter());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoMasuk())) {
						result.put("noMasuk", antrianPasienDiPeriksa.getNoMasuk());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
						result.put("statusAntrian", antrianPasienDiPeriksa.getStatusAntrian());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
						result.put("ruangan", antrianPasienDiPeriksa.getRuangan().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
						result.put("pasienDaftar", pasienDaftar.ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKamar())) {
						result.put("kamar", antrianPasienDiPeriksa.getKamar().ToMap());
						result.put("kamarId", antrianPasienDiPeriksa.getKamar().getId());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoBed())) {
						result.put("tempatTidur", antrianPasienDiPeriksa.getNoBed());
					}
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
						result.put("pasien", pasienDaftar.getPasien().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
						result.put("alamat", alamatDao.findAlamatByPasienId(pasienDaftar.getPasien().getId()).ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getNoRec())) {
						MappingPasienPacs mappingPasienPacs = mappingPasienPacsDao
								.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
						if (CommonUtil.isNotNullOrEmpty(mappingPasienPacs)) {
							result.put("studyId", mappingPasienPacs.getStudyInstanceUID());
							result.put("noMrPacs", mappingPasienPacs.getNoMr());
						}
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStrukOrder())) {
						Pegawai pegawaiOrder = antrianPasienDiPeriksa.getStrukOrder().getPegawaiOrder();
						if (CommonUtil.isNotNullOrEmpty(pegawaiOrder)) {
							result.put("pegawaiOrder", pegawaiOrder.ToMap());
						}
					}
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return result;
	}

	@Override
	public Map<String, Object> findAllAntrianPenunjangPaging(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
		}

		int totalRow = antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate, endDate, ruanganId, noCm,
				pegawaiId);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<StrukOrder> strukOrderList = antrianPasienDiPeriksaDaoCustom.findAllAntrianPenunjangPagingList(rowStart,
				rowEnd, startDate, endDate, ruanganId, noCm, pegawaiId);

		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (StrukOrder strukOrder : strukOrderList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			String noRegistrasi = strukOrder.getNoRegistrasi().getNoRegistrasi();
			Date tglOrder = strukOrder.getTglOrder();
			Integer idRuanganTujuan = strukOrder.getRuanganTujuan().getId();
			AntrianPasienDiPeriksa antrianPasien = antrianPasienDiPeriksaDao
					.findByNoRegisterKdRuanganAndTanggal(noRegistrasi, tglOrder, idRuanganTujuan);
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasien.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasien.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasien.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(
							pasienConverter.transferModelToVOCustom(antrianPasien.getPasienDaftar().getPasien(),
									new PasienVO(), new String[] { "namaPasien", "noCm" }));
				}
			}

			gridAntrianPasienDiPeriksaVO.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasien.getRuangan(),
					new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			gridAntrianPasienDiPeriksaVO
					.setPasienDaftar(pasienDaftarConverter.transferModelToVOCustom(antrianPasien.getPasienDaftar(),
							new PasienDaftarVO(), new String[] { "id", "noRegistrasi", "tglRegistrasi" }));
			if (antrianPasien.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
			} else if (antrianPasien.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
			} else if (antrianPasien.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
			} else if (antrianPasien.getStatusAntrian()
					.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
			}
			gridAntrianPasienDiPeriksaVO.setNoOrder(strukOrder.getNoOrder());
			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Autowired
	private AsalRujukanDao asalRujukanDao;

	@Autowired
	private KelompokPasienDao KelompokPasienDao;
	@Autowired
	private KasusPenyakitDao kasusPenyakitDao;

	@Autowired
	private StrukOrderDao strukOrderDao;

	@Autowired
	private OrderProdukDao orderProdukDao;

	@Autowired
	private BaseConverterImpl<OrderProdukVO, OrderProduk> orderProdukConverter;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePasienTouchScreen(RegistrasiPelayananVO vo) {

		vo.setKasusPenyakit(kasusPenyakitConverter.transferModelToVO(
				kasusPenyakitDao.findOne(Integer.parseInt(GetSettingDataFixed("KdKasusPenyakitUmum"))),
				new KasusPenyakitVO()));

		// vo.setKelompokPasien(kelompokPasienConverter.transferModelToVO(KelompokPasienDao.findOne(Integer.parseInt(GetSettingDataFixed("KdKasusPenyakitUmum")),
		// vo);
		// add by askur 03082016
		KelompokPasien kp = kelompokPasienDao.defaultKelompokPasien();
		KelompokPasienVO kpNew = new KelompokPasienVO();
		kpNew.setId(kp.getId());
		vo.setKelompokPasien(kpNew);
		//
		vo.setIsOnSiteService((byte) 0);
		vo.setIsRegistrasiLengkap((byte) 0);
		vo.setAsalRujukan(asalRujukanConverter.transferModelToVO(
				asalRujukanDao.findById(Integer.parseInt(GetSettingDataFixed("KdAsalRujukanDefault"))),
				new AsalRujukanVO()));
		return savePasienDafar(vo);
	}

	@Override
	@Transactional
	public Map<String, Object> getOrderLaboratorium(String noOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		List<OrderProduk> ordersProduk = orderProdukDao.findOrderByNoOrder(noOrder);

		Map<String, Object> maps = new HashMap<>();
		try {
			List<Map<String, Object>> list = orderProdukConverter.ToMaps(ordersProduk);
			List<Map<String, Object>> temp = new ArrayList<>();
			for (Map<String, Object> map : list) {
				map.put("detail", JsonUtil.ToMaps(orderProdukDao.findDetailOrderByIdOrder(strukOrder.getNoRec())));
				temp.add(map);
			}
			maps.put("orders", temp);
			maps.put("noOrder", strukOrder.getNoOrder());
			Ruangan ruangan = strukOrder.getRuanganTujuan();
			if (ruangan != null)
				maps.put("ruanganTujuan", ruangan.ToMap());
			else
				maps.put("ruanganTujuan", new HashMap<String, Object>());
			// maps.put("dokterPerujuk", strukOrder.getPegawaiOrder().ToMap());
			maps.put("tglDiRujuk", strukOrder.getTglOrder());
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}

		System.out.println(maps);
		return maps;
	}

	@Autowired
	private HasilPemeriksaanDao hasilPemeriksaanDao;
	@Autowired
	private ProdukDao produkDao;

	@Override
	@Transactional(readOnly = true)
	public Map<String, Object> getOrderDetailLaboratorium(String noOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		Map<String, Object> maps = new HashMap<>();

		try {
			List<Map<String, Object>> temp = new ArrayList<>();
			List<HasilPemeriksaan> hasilTindakan = hasilPemeriksaanDao.findByNoOrder(noOrder);
			if (hasilTindakan.size() == 0) {

				List<OrderPelayanan> ordersProduk = orderPelayananDao.findOrderByNoOrder(noOrder);
				for (OrderPelayanan map : ordersProduk) {
					Map<String, Object> mapData = new HashMap<>();

					Map<String, Object> hasil = new HashMap<>();
					Map<String, Object> produk = map.getProduk().ToMap();

					mapData.put("produk", produk);
					Set<ProdukDetailLaboratorium> data = map.getProduk().getProdukDetail();
					List<ProdukDetailLaboratorium> tempList = new ArrayList<>();

					double umur = DateUtil.getDaysBetweenDates(strukOrder.getNoCm().getTglLahir(),
							strukOrder.getTglOrder());
					Boolean valid = false;
					// add by askur 07122016
					List<ProdukDetailLaboratorium> dataSorting = new ArrayList<ProdukDetailLaboratorium>(data);
					Collections.sort(dataSorting, new Comparator<ProdukDetailLaboratorium>() {
						public int compare(ProdukDetailLaboratorium o1, ProdukDetailLaboratorium o2) {
							String i1 = o1.getqCharDetailPemeriksaan();
							String i2 = o2.getqCharDetailPemeriksaan();
							String i3 = o1.getDetailPemeriksaan();
							String i4 = o2.getDetailPemeriksaan();
							int i = i1.compareTo(i2);
							if (i == 0) {
								int j = i3.compareTo(i4);
								return j;
							}
							return i;
						}
					});
					//
					for (ProdukDetailLaboratorium produkDetailLaboratorium : dataSorting) {
						Set<ProdukDetailLaboratoriumNilaiNormal> tempDetailList = new HashSet<ProdukDetailLaboratoriumNilaiNormal>();
						for (ProdukDetailLaboratoriumNilaiNormal produkDetailLaboratoriumNilaiNormal : produkDetailLaboratorium
								.getProdukNilaiNormal()) {
							if (valid == false && produkDetailLaboratoriumNilaiNormal.getAgeUnit().equals("Y")) {
								valid = true;
								umur = umur / 365;

							} else if (valid == false && produkDetailLaboratoriumNilaiNormal.getAgeUnit().equals("M")) {
								umur = umur / 12;
								valid = true;
							}
							if (produkDetailLaboratoriumNilaiNormal.getAgeMin() <= umur
									&& produkDetailLaboratoriumNilaiNormal.getAgeMax() >= umur
									&& produkDetailLaboratoriumNilaiNormal.getJenisKelamin().getId() == strukOrder
											.getNoCm().getJenisKelamin().getId()) {
								// add by askur 06122016
								if (produkDetailLaboratoriumNilaiNormal.getPanicRange().equals("N")
										|| produkDetailLaboratoriumNilaiNormal.getPanicRange().equals("")) {
									//
									tempDetailList.add(produkDetailLaboratoriumNilaiNormal);
									//
								}
								//
							}
						}
						produkDetailLaboratorium.setProdukNilaiNormal(tempDetailList);
						tempList.add(produkDetailLaboratorium);

					}
					List<Map<String, Object>> detail = JsonUtil.ToMaps(tempList);
					for (Map<String, Object> map2 : detail) {
						System.err.println();
					}
					mapData.put("detail", detail);
					temp.add(mapData);
				}

			} else {
				maps.put("header", hasilTindakan.get(0).getstrukHasilPemeriksaan().ToMap());
				for (HasilPemeriksaan map : hasilTindakan) {
					Map<String, Object> mapData = new HashMap<>();
					Map<String, Object> produkMap = map.ToMap();
					Map<String, Object> data = (Map<String, Object>) produkMap.get("produk");
					if (map.getProduk().getJenisPeriksaPenunjang() != null)
						data.put("jenisPemeriksaanPenunjang", map.getProduk().getJenisPeriksaPenunjang().ToMap());
					else
						data.put("jenisPemeriksaanPenunjang", new HashMap<String, Object>());
					mapData.put("hasilPemeriksaan", produkMap);
					temp.add(mapData);
				}
			}
			maps.put("strukOrder", strukOrder.ToMap());
			maps.put("orders", temp);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return maps;
	}

	@Override
	@Transactional(readOnly = true)
	public Map<String, Object> getOrderDetail(String noOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		Map<String, Object> maps = new HashMap<>();

		try {
			List<Map<String, Object>> temp = new ArrayList<>();
			List<HasilPemeriksaan> hasilTindakan = hasilPemeriksaanDao.findByNoOrder(noOrder);
			if (hasilTindakan.size() == 0) {

				List<OrderPelayanan> ordersProduk = orderPelayananDao.findOrderByNoOrder(noOrder);
				for (OrderPelayanan map : ordersProduk) {
					Map<String, Object> mapData = new HashMap<>();

					Map<String, Object> hasil = new HashMap<>();
					Map<String, Object> produk = map.ToMap();

					mapData.put("produk", produk);

					temp.add(mapData);
				}

			}
			maps.put("strukOrder", strukOrder.ToMap());
			maps.put("orders", temp);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return maps;
	}

	@Autowired
	private StrukHasilPemeriksaanDao strukHasilPemeriksaanDao;

	@Override
	public Map<String, Object> ambilHasil(String noOrder, String namaPengambil, String noTelepon, Date date) {
		Map<String, Object> maps = new HashMap<>();
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		List<StrukHasilPemeriksaan> list = strukHasilPemeriksaanDao.findByNoOrder(noOrder);
		StrukHasilPemeriksaan struk = list.get(list.size() - 1);
		struk.setNamaPengambilHasil(namaPengambil);
		struk.setNoTeleponPengambilHasil(noTelepon);
		struk.setTanggalPengambilHasil(date);
		struk = strukHasilPemeriksaanDao.save(struk);
		maps.put("noRec", struk.getNoRec());
		return maps;
	}

	@Override
	public Map<String, Object> getOrderRadiologi(String noOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		List<OrderProduk> ordersProduk = orderProdukDao.findOrderByNoOrder(noOrder);

		Map<String, Object> maps = new HashMap<>();
		try {
			List<Map<String, Object>> list = orderProdukConverter.ToMaps(ordersProduk);
			List<Map<String, Object>> temp = new ArrayList<>();
			for (Map<String, Object> map : list) {
				map.put("detail", JsonUtil.ToMaps(orderProdukDao.findDetailOrderByIdOrder(strukOrder.getNoRec())));
				temp.add(map);
			}
			maps.put("orders", temp);
			maps.put("noOrder", strukOrder.getNoOrder());
			maps.put("ruanganTujuan", strukOrder.getRuanganTujuan().ToMap());
			// maps.put("dokterPerujuk", strukOrder.getPegawaiOrder().ToMap());
			maps.put("tglDiRujuk", strukOrder.getTglOrder());
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}

		System.out.println(maps);
		return maps;
	}

	// @Override
	public List<Map<String, Object>> findPelayananRawatInapOld(Short kdProfile, String noCm) {
		List<AntrianPasienDiPeriksa> temp = pasienDaftarDao.findPelayananRawatInap(kdProfile, noCm);
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Soap> listSoap = soapDao.findByPasienDaftar(noCm);
		for (Soap soapItem : listSoap) {
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("tanggal", new SimpleDateFormat("dd/MM/yyyy hh:mm:ss").format(soapItem.getTglInput()));
			// data.put("tanggal", new
			// SimpleDateFormat("dd/MM/yyyy").format(item.getTglRegistrasi()));
			data.put("s", soapItem.getS());
			data.put("o", soapItem.getO());
			data.put("a", soapItem.getA());
			data.put("p", soapItem.getP());
			if (CommonUtil.isNotNullOrEmpty(soapItem.getPegawai()))
				data.put("pegawai", soapItem.getPegawai().getNamaLengkap());
			else
				data.put("pegawai", "");
			// data.put("dokterPananggungJawab",
			// antrian.getPegawai().getNamaLengkap());
			// data.put("display", new SimpleDateFormat("dd
			// MMM").format(item.getTglRegistrasi()));
			data.put("display", new SimpleDateFormat("dd MMM").format(soapItem.getTglInput()));
			data.put("noRec", soapItem.getNoRec());
			data.put("noRecPasienDaftar", noCm);

			// PasienDaftar pasienDaftar = antrian.getPasienDaftar();

			// data.put("isKajianAwal", pasienDaftar.getIsKajianAwal());
			list.add(data);

		}
		return list;
	}

	@Override
	@Transactional
	public List<Map<String, Object>> findPersetujuanUmum(Short kdProfile, String noCm) {
		List<SuratPermintaanMasuk> temp = suratPermintaanMasukDao.findByPasienDaftarPasienDaftarPasienNoCm(noCm);
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		for (SuratPermintaanMasuk item : temp) {
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("tglRegistrasi", item.getPasien().getTglRegistrasi());
			data.put("noRec", item.getPasien().getPasienDaftar().getNoRec());
			AntrianPasienDiPeriksa antrian = item.getPasien();
			// data.put("tanggal",
			// item.getPasien().getPasienDaftar().getTglRegistrasi());
			data.put("tanggal", item.getPasien().getTglRegistrasi());
			try {
				data.put("diagnosa",
						JsonUtil.ToMaps(diagnosaPasienDao.findDiagnosaPasienByNoCmAndTglInput(
								antrian.getPasienDaftar().getPasien().getNoCm(),
								antrian.getPasienDaftar().getTglRegistrasi())));
				data.put("tindakan",
						JsonUtil.ToMaps(diagnosaPasienTindakanDao.findDiagnosaTindakanPasienByNoCmAndTglInput(
								antrian.getPasienDaftar().getPasien().getNoCm(),
								antrian.getPasienDaftar().getTglRegistrasi())));
			} catch (IllegalArgumentException | IllegalAccessException e) {
				e.printStackTrace();
			}
			data.put("laboratorium", new ArrayList<>());
			data.put("radiologi", "");
			data.put("konsultasi", new ArrayList<>());

			data.put("kasusPenyakit", antrian.getStatusPenyakit());
			data.put("obat", new ArrayList<>());
			if (antrian.getPegawai() != null)
				data.put("dokterPananggungJawab", antrian.getPegawai().getNamaLengkap());
			else
				data.put("dokterPananggungJawab", "");
			// edit by askur 28112016
			// data.put("display", new SimpleDateFormat("dd
			// MMM").format(item.getPasien().getPasienDaftar().getTglRegistrasi()));
			data.put("display", new SimpleDateFormat("dd MMM").format(item.getPasien().getTglRegistrasi()));
			//
			PasienDaftar pasienDaftar = antrian.getPasienDaftar();

			data.put("isKajianAwal", pasienDaftar.getIsKajianAwal());
			data.put("noRec", pasienDaftar.getNoRec());
			data.put("noRecAntrian", antrian.getNoRec());
			list.add(data);

			// data.put("diagnosa",
			// item.getPasien().getPasienDaftar().getNoRec());
			data.put("noCm", item.getPasien().getPasienDaftar().getPasien().getNoCm());
			list.add(data);
		}
		return list;
	}

	@Override
	@Transactional
	public List<Map<String, Object>> getOrderHistoryLaboratorium(Date date, Integer id, String noCm) {
		List<HasilPemeriksaan> list = hasilPemeriksaanDao.findHistoryDetail(date, id, noCm);
		try {
			return JsonUtil.ToMaps(list);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public List<Map<String, Object>> getLaporanHailPemeriksaan(String dateStart, String dateEnd, Integer id) {
		Date start = DateUtil.toDate(dateStart);
		start.setHours(0);
		start.setMinutes(0);
		start.setSeconds(0);

		Date endDate = DateUtil.toDate(dateEnd);
		endDate.setHours(23);
		endDate.setMinutes(59);
		endDate.setSeconds(59);
		List<HasilPemeriksaan> list = hasilPemeriksaanDao.getReportHasilPemeriksaan(start, endDate, id);
		try {
			List<Map<String, Object>> data = JsonUtil.ToMaps(list);
			for (Map<String, Object> map : data) {
				Map<String, Object> strukHasilPemeriksaan = (Map<String, Object>) map.get("strukHasilPemeriksaan");
				Map<String, Object> strukOrder = (Map<String, Object>) strukHasilPemeriksaan.get("strukOrder");
				Map<String, Object> noRegistrasi = (Map<String, Object>) strukOrder.get("noRegistrasi");
				if (noRegistrasi != null)
					strukOrder.put("noRegistrasi",
							pasienDaftarDao.findByNoRec(noRegistrasi.get("noRec").toString()).ToMap());
				Map<String, Object> noCm = (Map<String, Object>) strukOrder.get("noCm");
				if (noCm != null)
					strukOrder.put("noCm", pasienDao.findById(Integer.parseInt(noCm.get("id").toString())).ToMap());
			}
			return data;
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}

	public StrukOrder getStrukOrderByNoOrder(String noOrder) {
		return strukOrderDao.findByNoOrder(noOrder);
	}

	public List<HasilPemeriksaan> getHasilPemeriksaanByNoOrder(String noOrder) {
		return hasilPemeriksaanDao.findByNoOrder(noOrder);
	}

	@Override
	public Map<String, Object> getOrder(String noOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		List<OrderProduk> ordersProduk = orderProdukDao.findOrderByNoOrder(noOrder);

		Map<String, Object> maps = new HashMap<>();
		try {
			List<Map<String, Object>> list = orderProdukConverter.ToMaps(ordersProduk);
			List<Map<String, Object>> temp = new ArrayList<>();
			for (Map<String, Object> map : list) {
				map.put("detail", JsonUtil.ToMaps(orderProdukDao.findDetailOrderByIdOrder(strukOrder.getNoRec())));
				temp.add(map);
			}
			maps.put("orders", temp);
			maps.put("noOrder", strukOrder.getNoOrder());
			Ruangan ruangan = strukOrder.getRuanganTujuan();
			if (ruangan != null)
				maps.put("ruanganTujuan", ruangan.ToMap());
			else
				maps.put("ruanganTujuan", new HashMap<String, Object>());
			// maps.put("dokterPerujuk", strukOrder.getPegawaiOrder().ToMap());
			maps.put("tglDiRujuk", strukOrder.getTglOrder());
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}

		System.out.println(maps);
		return maps;
	}

	@Autowired
	private BaseConverterImpl<KelasVO, Kelas> kelasConverter;

	@Override
	@Transactional
	public Map<String, Object> findAllAntrianPaging(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId, Integer asalRuanganId,
			String namaPasien, Date tglLahir) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
		}

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingList(rowStart, rowEnd, startDate, endDate, ruanganId, noCm, pegawaiId,
						asalRuanganId, namaPasien, tglLahir);

		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			MappingPasienPacs mapping = mappingPasienPacsDao.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
			if (mapping != null) {
				gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
				gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO
						.setKelas(kelasConverter.transferModelToVO(antrianPasienDiPeriksa.getKelas(), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}
			try {
				Map<String, Object> map = pasienDaftarConverter.ToMap(antrianPasienDiPeriksa.getPasienDaftar());
				Gson gson = new Gson();
				String json = gson.toJson(map);

				gridAntrianPasienDiPeriksaVO.setPasienDaftar(gson.fromJson(json, PasienDaftarVO.class));

			} catch (IllegalArgumentException | IllegalAccessException e) {
				e.printStackTrace();
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	public Map<String, Object> findAllAntrianPagingPenunjangList(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId, Integer asalRuanganId,
			String namaPasien, Date tglLahir) {
		/*
		 * Date startDate = null; Date endDate = null; if
		 * (CommonUtil.isNotNullOrEmpty(dateStart)) { startDate =
		 * DateUtil.toDate(dateStart); } if
		 * (CommonUtil.isNotNullOrEmpty(dateEnd)) { endDate =
		 * DateUtil.toDate(dateEnd); }
		 */

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingPenunjangList(rowStart, rowEnd, convertDate(dateStart), convertDate(dateEnd),
						ruanganId, noCm, pegawaiId, asalRuanganId, namaPasien, tglLahir);
		Boolean isRadiologi = ruanganId == 35;
		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			if (isRadiologi == true) {
				MappingPasienPacs mapping = mappingPasienPacsDao
						.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
				if (mapping != null) {
					gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
					gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			if(CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin()))
			{
				gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());
			}
			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
					String workStation = "";
					for (JenisProduk jenisProduk : orderProdukDao
							.findJenisProdukOrderByIdOrder(antrianPasienDiPeriksa.getStrukOrder().getNoRec())) {
						workStation += jenisProduk.getJenisProduk() + ",";
					}
					;
					gridAntrianPasienDiPeriksaVO.setWorkStation(workStation);
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}
			try {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
					PasienDaftar pasiendaftarModel = pasienDaftarDao
							.findByNoRec(antrianPasienDiPeriksa.getPasienDaftar().getNoRec());
					PasienDaftarVO pasienDaftar = pasienDaftarConverter.transferModelToVOCustom(pasiendaftarModel,
							new PasienDaftarVO());
					/*
					 * Map<String, Object> map =
					 * pasienDaftarConverter.ToMap(antrianPasienDiPeriksa.
					 * getPasienDaftar()); Gson gson = new Gson(); String json =
					 * gson.toJson(map);
					 */

					gridAntrianPasienDiPeriksaVO.setPasienDaftar(pasienDaftar);
				}
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				AsalRujukanVO asalRujukanVO = new AsalRujukanVO();
				AsalRujukan model = antrianPasienDiPeriksa.getAsalRujukan();
				asalRujukanVO.setAsalRujukan(model.getAsalRujukan());
				asalRujukanVO.setId(model.getId());
				asalRujukanVO.setStatusEnabled(model.getStatusEnabled());
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanVO);
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Autowired
	private PelayananPasienDao pelayananPasienDao;

	@Override
	public Map<String, Object> getDataPelayananDarah(String noOrder) {
		Map<String, Object> maps = new HashMap<>();
		try {
			maps.put("pelayanan",
					JsonUtil.ToMaps(pelayananPasienDao.findByStrukOrderNoOrderAndKelompokTransaksiId(noOrder,
							Integer.parseInt(GetSettingDataFixed("KelompokTransaksiBankDarah")))));
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return maps;
	}

	public Ruangan findRuanganBilik(Integer id, Date tglRegistrasi) {
		List<RuanganJumlah> output = new ArrayList<RuanganJumlah>();
		// List<Ruangan> listRuangan=ruanganDao.findRuanganByParent(id);
		List<Ruangan> listRuangan = new ArrayList<Ruangan>();
		List<JadwalDokter> listJadwal = jadwalDokterDao.findJadwalByTanggalRuanganBilik(id, tglRegistrasi);
		if (listJadwal.isEmpty()) {
			List<JadwalDokter> listJadwal2 = jadwalDokterDao.findJadwalByTanggalRuanganBilik3(id, tglRegistrasi);
			for (JadwalDokter jd : listJadwal2) {
				listRuangan.add(jd.getRuangan());
			}
		}
		for (JadwalDokter jd : listJadwal) {
			listRuangan.add(jd.getRuangan());
		}
		for (Ruangan localR : listRuangan) {
			RuanganJumlah jml = new RuanganJumlah();
			// System.out.println("RUANGAN BILIK A : "+localR.getId()+"
			// "+localR.getNamaRuangan());
			List<Object[]> list = antrianPasienDiPeriksaDao.findRuanganByRuanganId(localR.getId(),
					DateUtil.formatDate(tglRegistrasi));
			for (Object[] o : list) {
				Long count = (Long) o[0];
				String namaR = (String) o[1];
				String tgl = (String) o[2];
				Integer idR = (Integer) o[3];
				if (localR.getNamaRuangan().equals(namaR)) {
					jml.setCount(count);
					jml.setNamaRuangan(namaR);
					jml.setIdRuangan(idR);
					jml.setTglRegistrasi(tgl);
					output.add(jml);
				}
			}
			if (jml.getIdRuangan() == null) {
				jml.setCount(0L);
				jml.setNamaRuangan(localR.getNamaRuangan());
				jml.setIdRuangan(localR.getId());
				output.add(jml);
			}
		}
		Collections.sort(output, new Comparator<RuanganJumlah>() {
			@Override
			public int compare(RuanganJumlah t, RuanganJumlah t1) {
				int a = Integer.parseInt(String.valueOf(t.getCount() - t1.getCount()));
				if (a == 0L) {
					int a1 = t.getNamaRuangan().compareTo(t1.getNamaRuangan());
					return a1;
				} else
					return a;
			}
		});
		// for(RuanganJumlah l:output){
		// System.out.println("RUANGAN BILIK B : "+l.getCount()+"
		// "+l.getIdRuangan()+" "+l.getNamaRuangan()+" "+l.getTglRegistrasi());
		// }
		Ruangan ruang = new Ruangan();
		if (CommonUtil.isNotNullOrEmpty(output)) {
			ruang.setId(output.get(0).getIdRuangan());
		}
		return ruang;
	}

	public AntrianPasienDiPeriksa setPegawaiRawatInap(String noRec, Integer idPegawai) {
		AntrianPasienDiPeriksa antrian = antrianPasienDiPeriksaDao.setPegawaiRawatInap(noRec);
		Pegawai pegawai = new Pegawai();
		pegawai.setId(idPegawai);
		antrian.setPegawai(pegawai);
		antrianPasienDiPeriksaDao.save(antrian);
		return antrian;
	}

	@Override
	public Map<String, Object> getPemeriksaanSeringLaboratorium(Integer id) {
		Map<String, Object> hashMap = new HashMap<String, Object>();
		List<HasilPemeriksaan> pemeriksaan = hasilPemeriksaanDao.getPemeriksaanSeringLaboratorium(id);
		try {
			hashMap.put("pemeriksaan", JsonUtil.ToMaps(pemeriksaan));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return hashMap;
	}

	@Override
	@Transactional
	// @Caching(cacheable = {
	// @Cacheable(value="testFindCache")
	// })

	public Map<String, Object> findAllAntrianPasienPulangPaging(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
		}

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPasienPulangPagingList(rowStart, rowEnd, startDate, endDate, ruanganId, noCm, pegawaiId);

		Boolean isRadiologi = ruanganId != null;
		if (isRadiologi == true)
			isRadiologi = ruanganId == 35;
		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			if (isRadiologi) {
				MappingPasienPacs mapping = mappingPasienPacsDao
						.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
				if (mapping != null) {
					gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
					gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO.setKelas(kelasConverter.transferModelToVO(
						JsonUtil.initializeAndUnproxy(antrianPasienDiPeriksa.getKelas()), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}
			try {
				Map<String, Object> map = pasienDaftarConverter.ToMap(antrianPasienDiPeriksa.getPasienDaftar());
				/*
				 * Gson gson = new Gson(); String json = gson.toJson(map);
				 * gridAntrianPasienDiPeriksaVO.setPasienDaftar(gson.fromJson(
				 * json, PasienDaftarVO.class));
				 */
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
					PasienDaftarVO pasienDaftarVO = new PasienDaftarVO();
					pasienDaftarVO.setNoRec(antrianPasienDiPeriksa.getPasienDaftar().getNoRec());
					pasienDaftarVO.setTglRegistrasi(antrianPasienDiPeriksa.getPasienDaftar().getTglRegistrasi());
					gridAntrianPasienDiPeriksaVO.setPasienDaftar(pasienDaftarVO);
				}

			} catch (IllegalArgumentException | IllegalAccessException e) {
				e.printStackTrace();
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("INDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			// edit by askur 30112016
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				Ruangan r = ruanganDao.findOne(antrianPasienDiPeriksa.getRuangan().getId());
				if (CommonUtil.isNotNullOrEmpty(r.getHeadRuangan())) {
					Ruangan ruanganParent = ruanganDao.findOne(r.getHeadRuangan().getId());
					gridAntrianPasienDiPeriksaVO.setRuangan(ruanganConverter.transferModelToVOCustom(ruanganParent,
							new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				} else {
					gridAntrianPasienDiPeriksaVO
							.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
									new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				}
			}
			//

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	@Transactional
	// @Caching(cacheable = {
	// @Cacheable(value="testFindCache")
	// })

	public Map<String, Object> findAllAntrianPagingRawatJalan(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Date startDate = null;
		Date endDate = null;
		/*
		 * if (CommonUtil.isNotNullOrEmpty(dateStart)) { startDate =
		 * DateUtil.toDate(dateStart); } if
		 * (CommonUtil.isNotNullOrEmpty(dateEnd)) { endDate =
		 * DateUtil.toDate(dateEnd); }
		 */

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingListRawatJalan(rowStart, rowEnd, convertDate(dateStart), convertDate(dateEnd),
						ruanganId, noCm, pegawaiId);

		Boolean isRadiologi = ruanganId != null;
		if (isRadiologi == true)
			isRadiologi = ruanganId == 35;
		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			if (isRadiologi) {
				MappingPasienPacs mapping = mappingPasienPacsDao
						.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
				if (mapping != null) {
					gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
					gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO.setKelas(kelasConverter.transferModelToVO(
						JsonUtil.initializeAndUnproxy(antrianPasienDiPeriksa.getKelas()), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin())) {
				gridAntrianPasienDiPeriksaVO.setJenisKelamin(
						antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());
			}

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
				PasienDaftarVO pasienDaftarVO = new PasienDaftarVO();
				pasienDaftarVO.setNoRec(antrianPasienDiPeriksa.getPasienDaftar().getNoRec());
				pasienDaftarVO.setTglRegistrasi(antrianPasienDiPeriksa.getPasienDaftar().getTglRegistrasi());
				gridAntrianPasienDiPeriksaVO.setPasienDaftar(pasienDaftarVO);
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	public Date convertDate(String date) {
		Date newDate = null;
		if (CommonUtil.isNotNullOrEmpty(date)) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			try {
				String h = date.substring(11, 13);
				String m = date.substring(14, 16);
				c.setTime(sdf.parse(date));

				c.set(Calendar.HOUR, Integer.valueOf(h));
				c.set(Calendar.MINUTE, Integer.valueOf(m));
				newDate = c.getTime();
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		return newDate;
	}

	@Override
	@Transactional
	// @Caching(cacheable = {
	// @Cacheable(value="testFindCache")
	// })

	public Map<String, Object> findAllAntrianPagingRawatInap(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId, String noRegistrasi) {

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingListRawatInap(rowStart, rowEnd, convertDate(dateStart), convertDate(dateEnd),
						ruanganId, noCm, pegawaiId, noRegistrasi);

		Boolean isRadiologi = ruanganId != null;
		if (isRadiologi == true)
			isRadiologi = ruanganId == 35;
		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			if (isRadiologi) {
				MappingPasienPacs mapping = mappingPasienPacsDao
						.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
				if (mapping != null) {
					gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
					gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO.setKelas(kelasConverter.transferModelToVO(
						JsonUtil.initializeAndUnproxy(antrianPasienDiPeriksa.getKelas()), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
				PasienDaftarVO pasienDaftarVO = new PasienDaftarVO();
				pasienDaftarVO.setNoRec(antrianPasienDiPeriksa.getPasienDaftar().getNoRec());
				pasienDaftarVO.setTglRegistrasi(antrianPasienDiPeriksa.getPasienDaftar().getTglRegistrasi());
				gridAntrianPasienDiPeriksaVO.setPasienDaftar(pasienDaftarVO);
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			// edit by askur 30112016
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				Ruangan r = ruanganDao.findOne(antrianPasienDiPeriksa.getRuangan().getId());
				if (CommonUtil.isNotNullOrEmpty(r.getHeadRuangan())) {
					Ruangan ruanganParent = ruanganDao.findOne(r.getHeadRuangan().getId());
					gridAntrianPasienDiPeriksaVO.setRuangan(ruanganConverter.transferModelToVOCustom(ruanganParent,
							new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				} else {
					gridAntrianPasienDiPeriksaVO
							.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
									new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				}
			}
			//

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	@Transactional
	// @Caching(cacheable = {
	// @Cacheable(value="testFindCache")
	// })

	public Map<String, Object> findAllAntrianPagingKonsultasi(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
		}

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingListKonsultasi(rowStart, rowEnd, startDate, endDate, ruanganId, noCm, pegawaiId);

		Boolean isRadiologi = ruanganId != null;
		if (isRadiologi == true)
			isRadiologi = ruanganId == 35;
		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			if (isRadiologi) {
				MappingPasienPacs mapping = mappingPasienPacsDao
						.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
				if (mapping != null) {
					gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
					gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO.setKelas(kelasConverter.transferModelToVO(
						JsonUtil.initializeAndUnproxy(antrianPasienDiPeriksa.getKelas()), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}
			try {
				Map<String, Object> map = pasienDaftarConverter.ToMap(antrianPasienDiPeriksa.getPasienDaftar());
				Gson gson = new Gson();
				String json = gson.toJson(map);

				gridAntrianPasienDiPeriksaVO.setPasienDaftar(gson.fromJson(json, PasienDaftarVO.class));

			} catch (IllegalArgumentException | IllegalAccessException e) {
				e.printStackTrace();
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			// edit by askur 30112016
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				Ruangan r = ruanganDao.findOne(antrianPasienDiPeriksa.getRuangan().getId());
				if (CommonUtil.isNotNullOrEmpty(r.getHeadRuangan())) {
					Ruangan ruanganParent = ruanganDao.findOne(r.getHeadRuangan().getId());
					gridAntrianPasienDiPeriksaVO.setRuangan(ruanganConverter.transferModelToVOCustom(ruanganParent,
							new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				} else {
					gridAntrianPasienDiPeriksaVO
							.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
									new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				}
			}
			//
			// List<Konsultasi> listKonsultasi =
			// konsultasiDao.findAllByNoRecAntrian(antrianPasienDiPeriksa.getNoRec());
			List<PasienDiRujukKeIntExt> listKonsultasi = pasienDiRujukKeIntExtDao
					.findAllByNoRecAntrian(antrianPasienDiPeriksa.getNoRec());
			for (PasienDiRujukKeIntExt local : listKonsultasi) {
				KonsultasiVO konsultasi = new KonsultasiVO();
				konsultasi.setNoRec(local.getNoRec());
				konsultasi.setAntrianPasienDiPeriksa(null);
				konsultasi.setIkhtiarKlinik(local.getKeteranganLainnya());
				konsultasi.setTanggalKonsultasi(local.getTglDirujuk());
				konsultasi.setTujuanKonsultasi(ruanganConverter.transferModelToVOCustom(local.getRuanganTujuan(),
						new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
				gridAntrianPasienDiPeriksaVO.setKonsultasi(konsultasi);
			}
			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	public Map<String, Object> getKelompokPasien() {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> listData = pasienDaftarDao.getKelompokPasien();
		if (CommonUtil.isNotNullOrEmpty(listData)) {
			result.put("listData", listData);
		}
		return result;
	}

	@Override
	public Map<String, Object> getRekananByKelompokPasien(Integer id) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> listData = pasienDaftarDao.getRekananByKelompokPasien(id);
		if (CommonUtil.isNotNullOrEmpty(listData)) {
			result.put("listData", listData);
		}
		return result;
	}

	@Override
	public Map<String, Object> getLoadData(Integer rekananId, String noCm) {
		Map<String, Object> result = new HashMap<>();
		Map<String, Object> dataPasien = pasienDaftarDao.getDataExistingAsuransiPasien(rekananId, noCm);
		if (CommonUtil.isNotNullOrEmpty(dataPasien)) {
			result.put("dataPasienExisting", dataPasien);
		}
		result.put("hubunganPesertaAsuransi", pasienDaftarDao.getHubunganPesertaAsuransi());
		result.put("unitBagian", pasienDaftarDao.getRuangan());
		result.put("kelasDitanggung", pasienDaftarDao.getKelas());
		result.put("diagnosa", pasienDaftarDao.getDiagnosa());
		result.put("golonganAsuransi", pasienDaftarDao.getGolonganAsuransi());
		result.put("namaPerujuk", pasienDaftarDao.getDokter());
		return result;
	}

	@Override
	public Map<String, Object> getDataAsuransiPasien(Integer id, String noCm) {
		Map<String, Object> result = new HashMap<>();
		Map<String, Object> dataPasien = pasienDaftarDao.getDataAsuransiPasien(noCm, id);
		if (CommonUtil.isNotNullOrEmpty(dataPasien)) {
			result.put("dataPasien", dataPasien);
		}
		return result;
	}

	// ---------------------------------------------------------------------------------------------------------------
	/*
	 * ASURANSI BPJS
	 * 
	 * @see com.jasamedika.medifirst2000.service.RegistrasiPelayananService#
	 * saveAsuransiPasien(com.jasamedika.medifirst2000.vo.AsuransiPasienVO)
	 */

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveAsuransiPasien(AsuransiRegistrasiPasienVO vos) {
		Map<String, Object> result = new HashMap<>();

		AsuransiPasienVO vo = vos.getAsuransiPasien();

		if (CommonUtil.isNotNullOrEmpty(vo)) {
			if (CommonUtil.isNotNullOrEmpty(vo.getNoCm())) {
				AsuransiPasien asuransiPasien = asuransiPasienConverter.transferVOToModel(vo, new AsuransiPasien());
				AsuransiPasien asuransi = asuransiPasienDao.getAsuransiByPasien(vo.getNoAsuransi(),
						vo.getNoCm().getId());
				if (CommonUtil.isNotNullOrEmpty(asuransi)) {
					asuransiPasien.setId(asuransi.getId());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getGolonganAsuransi())) {
					asuransiPasien.setGolonganAsuransi(golonganAsuransiConverter
							.transferVOToModel(vo.getGolonganAsuransi(), new GolonganAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getHubunganPeserta())) {
					asuransiPasien.setHubunganPeserta(hubunganPesertaAsuransiConverter
							.transferVOToModel(vo.getHubunganPeserta(), new HubunganPesertaAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKelasDiJamin())) {
					asuransiPasien.setKelasDiJamin(kelasConverter.transferVOToModel(vo.getKelasDiJamin(), new Kelas()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					asuransiPasien.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
					asuransiPasien.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getJenisPeserta())) {
					asuransiPasien.setJenisPeserta(vo.getJenisPeserta());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNmProvider())) {
					asuransiPasien.setNmProvider(vo.getNmProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKdProvider())) {
					asuransiPasien.setKdProvider(vo.getKdProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNoCm())) {
					asuransiPasien.setNoCm(pasienConverter.transferVOToModel(vo.getNoCm(), new Pasien()));
				}
				if (CommonUtil.isNotNullOrEmpty(asuransiPasien)) {
					Map<String, Object> registrasi = savePasienDafar(vos.getRegistrasiPelayanan());

					if (CommonUtil.isNotNullOrEmpty(registrasi)) {
						if (CommonUtil.isNotNullOrEmpty(registrasi.get("statusPasien"))) {
							result.put("statusPasien", registrasi.get("statusPasien"));
							Map<String, Object> delete = bridgingBpjs.deleteSep(vo.getNoSep());
							if (CommonUtil.isNotNullOrEmpty(delete.get("response"))) {
								result.put("delete sep", vo.getNoSep());
							}
						} else {
							AsuransiPasien asuransiPasienResult = asuransiPasienDao.save(asuransiPasien);
							if (CommonUtil.isNotNullOrEmpty(asuransiPasienResult)) {

								Map<String, Object> pemakaianAsuransi = savePemakaianAsuransi(asuransiPasien, vos,
										registrasi);
								result.putAll(pemakaianAsuransi);
								result.putAll(registrasi);
								result.put("sep", vo.getNoSep());
								if (CommonUtil.isNotNullOrEmpty(vo.getNoSep())
										&& CommonUtil.isNotNullOrEmpty(registrasi.get("noRegistrasi"))) {
									Map<String, Object> mapping = bridgingBpjs.mappingTransaksiSep(vo.getNoSep(),
											registrasi.get("noRegistrasi") + "");
									result.put("response", mapping.get("response"));
								}
							}
						}
					}
				}
			}
		}
		return result;

	}

	@SuppressWarnings("unchecked")
	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePemakaianAsuransi(AsuransiPasien asuransiPasien, AsuransiRegistrasiPasienVO vos,
			Map<String, Object> registrasi) {
		Map<String, Object> result = new HashMap<>();

		AsuransiPasienVO vo = vos.getAsuransiPasien();
		if (CommonUtil.isNotNullOrEmpty(vo)) {

			PemakaianAsuransi pemakaianAsuransi = pemakaianAsuransiDao.findByPasienDaftar(registrasi.get("noRec") + "");
			if (CommonUtil.isNullOrEmpty(pemakaianAsuransi)) {
				pemakaianAsuransi = new PemakaianAsuransi();
			}
			if (CommonUtil.isNotNullOrEmpty(vos.getAsuransiPasien().getCatatan())) {
				pemakaianAsuransi.setCatatan(vos.getAsuransiPasien().getCatatan());
			}
			if (CommonUtil.isNotNullOrEmpty(asuransiPasien)) {
				pemakaianAsuransi.setAsuransiPasien(asuransiPasien);
			}
			if (CommonUtil.isNotNullOrEmpty(registrasi.get("noRec"))) {
				pemakaianAsuransi.setPasienDaftar(pasienDaftarDao.findOne((String) registrasi.get("noRec")));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getPpkRujukan())) {
				pemakaianAsuransi.setPpkRujukan(vo.getPpkRujukan());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getDiagnosis())) {
				pemakaianAsuransi.setDiagnosis(diagnosaConverter.transferVOToModel(vo.getDiagnosis(), new Diagnosa()));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getNoKepesertaan())) {
				pemakaianAsuransi.setNoKepesertaan(vo.getNoKepesertaan());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getLakalantas())) {
				pemakaianAsuransi.setLakalantas(vo.getLakalantas());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getTglRujukan())) {
				pemakaianAsuransi.setTglRujukan(vo.getTglRujukan());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRujukan())) {
				pemakaianAsuransi.setNoRujukan(vo.getNoRujukan());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getNoSep())) {
				pemakaianAsuransi.setNoSep(vo.getNoSep());
				Map<String, Object> returnDetailSep = bridgingBpjs.getDetailSEP(vo.getNoSep());
				if (CommonUtil.isNotNullOrEmpty(returnDetailSep)) {
					Map<String, Object> response = (Map<String, Object>) returnDetailSep.get("response");
					if (CommonUtil.isNotNullOrEmpty(response)) {
						Map<String, Object> model = saveDetailSep(response);
						result.putAll(model);
					}
				}
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getDiagnosa())) {
				pemakaianAsuransi.setDiagnosa(diagnosaConverter.transferVOToModel(vo.getDiagnosa(), new Diagnosa()));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getTanggalSep())) {
				pemakaianAsuransi.setTanggalSep(vo.getTanggalSep());
			}
			if (CommonUtil.isNotNullOrEmpty(pemakaianAsuransi)) {
				PemakaianAsuransi model = pemakaianAsuransiDao.save(pemakaianAsuransi);
				result.put("norecPemakaianAsuransi", model.getNoRec());
			}
		}
		return result;
	}

	// ---------------------------------------------------------------------------------------------------------------

	@Override
	public Map<String, Object> getTindakanPelayanan(String noRec) {
		Map<String, Object> result = new HashMap<>();

		if (CommonUtil.isNotNullOrEmpty(noRec)) {
			List<Map<String, Object>> listData = pasienDaftarDao.getTindakanPelayanan3(noRec);

			if (CommonUtil.isNotNullOrEmpty(listData)) {
				result.put("listData", listData);
			}
		}
		return result;
	}

	@Override
	public List<Map<String, Object>> findPelayananRawatInap(Short kdProfile, String noCm) {
		List<PasienDaftar> temp = pasienDaftarDao.findPelayananRawatJalan(kdProfile, noCm);
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		for (PasienDaftar item : temp) {

			for (AntrianPasienDiPeriksa map : antrianPasienDiPeriksaDao
					.findByNoRegisterNonRawatInap(item.getNoRegistrasi())) {
				AntrianPasienDiPeriksa antrian = map;
				Map<String, Object> data = new HashMap<String, Object>();
				data.put("tanggal", map.getTglRegistrasi());
				try {
					data.put("diagnosa",
							JsonUtil.ToMaps(diagnosaPasienDao.findDiagnosaPasienByNoCmAndTglInput(
									antrian.getPasienDaftar().getPasien().getNoCm(),
									antrian.getPasienDaftar().getTglRegistrasi())));
					data.put("tindakan",
							JsonUtil.ToMaps(diagnosaPasienTindakanDao.findDiagnosaTindakanPasienByNoCmAndTglInput(
									antrian.getPasienDaftar().getPasien().getNoCm(),
									antrian.getPasienDaftar().getTglRegistrasi())));
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
				data.put("laboratorium", new ArrayList<>());
				data.put("radiologi", "");
				data.put("konsultasi", new ArrayList<>());

				data.put("kasusPenyakit", antrian.getStatusPenyakit());
				data.put("obat", new ArrayList<>());
				if (antrian.getPegawai() != null)
					data.put("dokterPananggungJawab", antrian.getPegawai().getNamaLengkap());
				else
					data.put("dokterPananggungJawab", "");
				data.put("display", new SimpleDateFormat("dd MMM").format(item.getTglRegistrasi()));
				PasienDaftar pasienDaftar = antrian.getPasienDaftar();

				data.put("isKajianAwal", pasienDaftar.getIsKajianAwal());
				data.put("noRec", antrian.getNoRec());
				list.add(data);
			}
		}
		return list;

	}

	@Override
	@Transactional
	public List<Map<String, Object>> findPealyananRawatJalanByNoCmAndTglregistrasi(Short kdProfile, String noCm,
			String tglRegistrasi) {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		List<DiagnosaPasien> listDiagnosa = antrianPasienDiPeriksaDao.findDiagnosaPasien(noCm, tglRegistrasi);
		for (DiagnosaPasien data : listDiagnosa) {
			Set<DetailDiagnosaPasien> listDetailDiagnosaPasien = data.getDiagnosis();
			for (DetailDiagnosaPasien detailDiagnosaPasien : listDetailDiagnosaPasien) {
				Map<String, Object> realData = new HashMap<String, Object>();
				realData.put("tglInput",
						new SimpleDateFormat("dd-MM-yyyy HH.mm").format(detailDiagnosaPasien.getTglInputDiagnosa()));
				Diagnosa diagnosa = detailDiagnosaPasien.getDiagnosa();
				AntrianPasienDiPeriksa antrianPasienDiPeriksa = detailDiagnosaPasien.getPasien();
				Pegawai pegawai = antrianPasienDiPeriksa.getPegawai();
				Ruangan ruangan = antrianPasienDiPeriksa.getRuangan();
				realData.put("diagnosa", diagnosa.getNamaDiagnosa());
				realData.put("dokter", pegawai.getNamaLengkap());
				realData.put("ruangan", ruangan.getNamaRuangan());
				realData.put("kelompokPasien",
						antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());
				result.add(realData);
			}
		}
		return result;
	}

	@Override
	public List<Map<String, Object>> findJenisProdukRadiologi() {
		String idJenisProduk = registrasiPelayananPasienDao.findIdJenisProduk();
		List<Map<String, Object>> result = registrasiPelayananPasienDao
				.findJenisProduk(Integer.parseInt(idJenisProduk));
		return result;
	}

	// edited by susy
	@Override
	@Transactional
	public Map<String, Object> findAllAntrianPagingByPemeriksaan(Integer page, Integer limit, String sort, String dir,
			Integer ruanganId, String dateStart, String dateEnd, String noCm, Integer pegawaiId, Integer asalRuanganId,
			String namaPasien, Date tglLahir, String idJenisProduk) {
		Date startDate = null;
		Date endDate = null;
		if (CommonUtil.isNotNullOrEmpty(dateStart)) {
			startDate = DateUtil.toDate(dateStart);
		}
		if (CommonUtil.isNotNullOrEmpty(dateEnd)) {
			endDate = DateUtil.toDate(dateEnd);
		}

		int totalRow = 0;// antrianPasienDiPeriksaDaoCustom.findAllAntrianPagingCount(startDate,
							// endDate, ruanganId, noCm);
		int totalPages = 0;

		int pageRequested = page;

		if (totalRow > 0) {
			totalPages = (int) Math.ceil((double) totalRow / (double) limit);
		} else {
			totalPages = 0;
		}

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}

		int rowEnd = limit;
		String[] idJenis = idJenisProduk.split(",");
		List<Integer> id = new ArrayList<Integer>();
		for (int i = 0; i < idJenis.length; i++) {
			Integer temp = Integer.valueOf(idJenis[i]);
			id.add(temp);
		}
		List<AntrianPasienDiPeriksa> antrianPasienDiPeriksaList = antrianPasienDiPeriksaDaoCustom
				.findAllAntrianPagingRadiologiList(rowStart, rowEnd, startDate, endDate, ruanganId, noCm, pegawaiId,
						asalRuanganId, namaPasien, tglLahir, id);

		List<GridAntrianPasienDiPeriksaVO> gridAntrianPasienDiPeriksaVoList = new ArrayList<GridAntrianPasienDiPeriksaVO>();
		for (AntrianPasienDiPeriksa antrianPasienDiPeriksa : antrianPasienDiPeriksaList) {
			GridAntrianPasienDiPeriksaVO gridAntrianPasienDiPeriksaVO = new GridAntrianPasienDiPeriksaVO();
			Map<String, Object> pemeriksaan = antrianPasienDiPeriksaDao
					.findProdukByNoRecAntrian(antrianPasienDiPeriksa.noRec);
			gridAntrianPasienDiPeriksaVO.setNoRec(antrianPasienDiPeriksa.getNoRec());
			gridAntrianPasienDiPeriksaVO.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
			if (CommonUtil.isNotNullOrEmpty(pemeriksaan.get("pemeriksaan"))) {
				gridAntrianPasienDiPeriksaVO.setPemeriksaan((String) pemeriksaan.get("pemeriksaan"));
				gridAntrianPasienDiPeriksaVO.setIdPemeriksaan((Integer) pemeriksaan.get("idProduk"));
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftarId())) {
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar().getPasienId())) {
					gridAntrianPasienDiPeriksaVO.setPasien(pasienConverter.transferModelToVOCustom(
							antrianPasienDiPeriksa.getPasienDaftar().getPasien(), new PasienVO(),
							new String[] { "namaPasien", "noCm", "jenisKelamin" }));
				}
			}
			MappingPasienPacs mapping = mappingPasienPacsDao.findByPasienDaftarNoRec(antrianPasienDiPeriksa.getNoRec());
			if (mapping != null) {
				gridAntrianPasienDiPeriksaVO.setStudyId(mapping.getStudyInstanceUID());
				gridAntrianPasienDiPeriksaVO.setNoMrPacs(mapping.getNoMr());
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getRuangan())) {
				gridAntrianPasienDiPeriksaVO
						.setRuangan(ruanganConverter.transferModelToVOCustom(antrianPasienDiPeriksa.getRuangan(),
								new RuanganVO(), new String[] { "id", "namaRuangan", "kdRuangan" }));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getKelas())) {
				gridAntrianPasienDiPeriksaVO
						.setKelas(kelasConverter.transferModelToVO(antrianPasienDiPeriksa.getKelas(), new KelasVO()));
			}
			gridAntrianPasienDiPeriksaVO.setIsKajianAwal(antrianPasienDiPeriksa.getPasienDaftar().getIsKajianAwal());
			gridAntrianPasienDiPeriksaVO.setJenisKelamin(
					antrianPasienDiPeriksa.getPasienDaftar().getPasien().getJenisKelamin().getJenisKelamin());

			gridAntrianPasienDiPeriksaVO.setKelompokPasien(
					antrianPasienDiPeriksa.getPasienDaftar().getKelompokPasien().getKelompokPasien());

			if (antrianPasienDiPeriksa.getStrukOrder() != null) {
				try {
					gridAntrianPasienDiPeriksaVO.setStrukOrder(antrianPasienDiPeriksa.getStrukOrder().ToMap());
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStrukOrder(new HashMap<String, Object>());
			}
			// try {
			/*
			 * Map<String, Object> map =
			 * pasienDaftarConverter.ToMap(antrianPasienDiPeriksa.
			 * getPasienDaftar()); Gson gson = new Gson(); String json =
			 * gson.toJson(map);
			 */

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPasienDaftar())) {
				PasienDaftarVO pasienDaftar = pasienDaftarConverter
						.transferModelToVOCustom(antrianPasienDiPeriksa.getPasienDaftar(), new PasienDaftarVO());
			}

			/*
			 * } catch (IllegalArgumentException | IllegalAccessException e) {
			 * e.printStackTrace(); }
			 */

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getAsalRujukan())) {
				gridAntrianPasienDiPeriksaVO.setAsalRujukan(asalRujukanConverter
						.transferModelToVO(antrianPasienDiPeriksa.getAsalRujukan(), new AsalRujukanVO()));
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getStatusAntrian())) {
				if (antrianPasienDiPeriksa.getStatusAntrian().equalsIgnoreCase(StatusAntrianEnum.MENUNGGU.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.MENUNGGU.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_SUSTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_SUSTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.DIPANGGIL_DOKTER.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.DIPANGGIL_DOKTER.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERSIAPAN.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERSIAPAN.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.PERIKSA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.PERIKSA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.AMBIIL_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.AMBIIL_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SELESAI_HASIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SELESAI_HASIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_AMBIL.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_AMBIL.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_TERIMA.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_TERIMA.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.SAMPLE_DI_VERIFIKASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.STATUS_CETAK.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.STATUS_CETAK.toString());
				} else if (antrianPasienDiPeriksa.getStatusAntrian()
						.equalsIgnoreCase(StatusAntrianEnum.VALIDASI_ANALIS.getVal())) {
					gridAntrianPasienDiPeriksaVO.setStatusAntrian(StatusAntrianEnum.VALIDASI_ANALIS.toString());
				}
			} else {
				gridAntrianPasienDiPeriksaVO.setStatusAntrian("UNDIFINED");
			}

			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa.getPegawai())) {
				gridAntrianPasienDiPeriksaVO.setDokter(antrianPasienDiPeriksa.getPegawai().getNamaLengkap());
			}

			gridAntrianPasienDiPeriksaVoList.add(gridAntrianPasienDiPeriksaVO);

		}

		return constructMapReturn(gridAntrianPasienDiPeriksaVoList, totalRow, totalPages);
	}

	@Override
	public Map<String, Object> updatePelayananDokter(Map<String, Object> value) {
		Map<String, Object> result = new HashMap<>();

		if (CommonUtil.isNotNullOrEmpty(value)) {
			Map<String, Object> pegawai = (Map<String, Object>) value.get("pegawai");
			if (CommonUtil.isNotNullOrEmpty(pegawai)) {
				String noRec = (String) value.get("noRec");
				Integer pegawaiId = (Integer) pegawai.get("id");

				PasienDaftar pasienDaftar = pasienDaftarDao.findOne(noRec);

				if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
					Pegawai dokter = pegawaiDao.findOne(pegawaiId);

					if (CommonUtil.isNotNullOrEmpty(dokter)) {
						pasienDaftar.setDokterPenanggungJawab(dokter);
					}
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getAntrianPasienDiPeriksaSet())) {
						for (AntrianPasienDiPeriksa model : pasienDaftar.getAntrianPasienDiPeriksaSet()) {
							model.setPegawai(dokter);
							antrianPasienDiPeriksaDao.save(model);
						}
					}
				}
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
					PasienDaftar pasienDaftarResult = pasienDaftarDao.save(pasienDaftar);
					result.put("noRec", pasienDaftarResult.getNoRec());
				}
			}
		}
		return result;
	}

	@Override
	public List<Map<String, Object>> getRuanganIGD() {
		String idField = GetSettingDataFixed("KdDepartemenInstalasiGawatDarurat");
		List<Map<String, Object>> result = ruanganDao.getRuanganIGD(Integer.valueOf(idField));
		return result;
	}

	@Override
	public Map<String, Object> getDataPasien(String noCm) {
		Map<String, Object> result = new HashMap<>();
		try {
			if (CommonUtil.isNotNullOrEmpty(noCm)) {
				List<Map<String, Object>> pasiens = pasienDao.getPasien(noCm);
				if (CommonUtil.isNotNullOrEmpty(pasiens)) {
					Map<String, Object> pasien = pasiens.get(0);
					Alamat alamat = pasienDao.getAlamatByPasien(noCm);

					if (CommonUtil.isNotNullOrEmpty(pasien.get("jenisKelaminId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("jenisKelaminId"));
						pasien.put("jenisKelamin", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("jenisKelamin", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("agamaId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("agamaId"));
						pasien.put("agama", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("agama", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("statusKawinId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("statusKawinId"));
						pasien.put("statusPerkawinan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("statusPerkawinan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("pendidikanId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("pendidikanId"));
						pasien.put("pendidikan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("pendidikan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("pekerjaanId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("pekerjaanId"));
						pasien.put("pekerjaan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("pekerjaan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("kebangsaanId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("kebangsaanId"));
						pasien.put("kebangsaan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("kebangsaan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(pasien.get("negaraId"))) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", pasien.get("negaraId"));
						pasien.put("negara", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("negara", data);
					}

					if (CommonUtil.isNotNullOrEmpty(alamat.getAlamatLengkap())) {
						pasien.put("alamat", alamat.getAlamatLengkap());
					}
					if (CommonUtil.isNotNullOrEmpty(alamat.getKodePos())) {
						pasien.put("kodepos", alamat.getKodePos());
					}
					if (CommonUtil.isNotNullOrEmpty(alamat.getDesaKelurahan())) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", alamat.getDesaKelurahan().getId());
						pasien.put("kelurahan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("kelurahan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(alamat.getKecamatan())) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", alamat.getKecamatan().getId());
						pasien.put("kecamatan", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("kecamatan", data);
					}

					if (CommonUtil.isNotNullOrEmpty(alamat.getKotaKabupaten())) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", alamat.getKotaKabupaten().getId());
						pasien.put("kotaKabupaten", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("kotaKabupaten", data);
					}

					if (CommonUtil.isNotNullOrEmpty(alamat.getPropinsi())) {
						Map<String, Object> data = new HashMap<>();
						data.put("id", alamat.getPropinsi().getId());
						pasien.put("propinsi", data);
					} else {
						Map<String, Object> data = new HashMap<>();
						data.put("id", null);
						pasien.put("propinsi", data);
					}
					if (CommonUtil.isNotNullOrEmpty(pasien)) {
						result = pasien;
					}
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}

		return result;
	}

	@Autowired
	BaseConverterImpl<AgamaVO, Agama> agamaConverter;
	@Autowired
	BaseConverterImpl<JenisKelaminVO, JenisKelamin> jenisKelaminConverter;
	@Autowired
	BaseConverterImpl<StatusPerkawinanVO, StatusPerkawinan> statusPerkawinanConverter;
	@Autowired
	BaseConverterImpl<PendidikanVO, Pendidikan> pendidikanConverter;
	@Autowired
	BaseConverterImpl<PekerjaanVO, Pekerjaan> pekerjaanConverter;
	@Autowired
	BaseConverterImpl<KebangsaanVO, Kebangsaan> kebangsaanConverter;
	@Autowired
	BaseConverterImpl<NegaraVO, Negara> negaraConverter;
	@Autowired
	BaseConverterImpl<DesaKelurahanVO, DesaKelurahan> desaKelurahanConverter;
	@Autowired
	BaseConverterImpl<KecamatanVO, Kecamatan> kecamatanConverter;
	@Autowired
	BaseConverterImpl<KotaKabupatenVO, KotaKabupaten> KotaKabupatenConverter;
	@Autowired
	BaseConverterImpl<PropinsiVO, Propinsi> propinsiConverter;

	@Override
	public Map<String, Object> updatePasienDaftar(PasienVO vo) {
		Map<String, Object> result = new HashMap<>();

		Pasien pasien = pasienDao.findById(vo.getId());
		if (CommonUtil.isNotNullOrEmpty(vo.getAgama())) {
			pasien.setAgama(agamaConverter.transferVOToModel(vo.getAgama(), new Agama()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNamaPasien())) {
			pasien.setNamaPasien(vo.getNamaPasien());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getTempatLahir())) {
			pasien.setTempatLahir(vo.getTempatLahir());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getTglLahir())) {
			pasien.setTglLahir(vo.getTglLahir());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getJenisKelamin())) {
			pasien.setJenisKelamin(jenisKelaminConverter.transferVOToModel(vo.getJenisKelamin(), new JenisKelamin()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getStatusPerkawinan())) {
			pasien.setStatusPerkawinan(
					statusPerkawinanConverter.transferVOToModel(vo.getStatusPerkawinan(), new StatusPerkawinan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getPendidikan())) {
			pasien.setPendidikan(pendidikanConverter.transferVOToModel(vo.getPendidikan(), new Pendidikan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getPekerjaan())) {
			pasien.setPekerjaan(pekerjaanConverter.transferVOToModel(vo.getPekerjaan(), new Pekerjaan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getKebangsaan())) {
			pasien.setKebangsaan(kebangsaanConverter.transferVOToModel(vo.getKebangsaan(), new Kebangsaan()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNegara())) {
			pasien.setNegara(negaraConverter.transferVOToModel(vo.getNegara(), new Negara()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNoBpjs())) {
			pasien.setNoBpjs(vo.getNoBpjs());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNoAsuransiLain())) {
			pasien.setNoAsuransiLain(vo.getNoAsuransiLain());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNamaAyah())) {
			pasien.setNamaAyah(vo.getNamaAyah());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNamaIbu())) {
			pasien.setNamaIbu(vo.getNamaIbu());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNamaSuamiIstri())) {
			pasien.setNamaSuamiIstri(vo.getNamaSuamiIstri());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNoTelepon())) {
			pasien.setNoTelepon(vo.getNoTelepon());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNoHp())) {
			pasien.setNoHp(vo.getNoHp());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNoCm())) {
			pasien.setNoCm(vo.getNoCm());
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getNamaKeluarga())) {
			pasien.setNamaKeluarga(vo.getNamaKeluarga());
		}

		Set<Alamat> alamats = pasien.getAlamats();
		if (CommonUtil.isNotNullOrEmpty(alamats)) {
			for (Alamat alamat : pasien.getAlamats()) {
				if (CommonUtil.isNotNullOrEmpty(vo.getAlamatLengkap())) {
					alamat.setAlamatLengkap(vo.getAlamatLengkap());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKodePos())) {
					alamat.setKodePos(vo.getKodePos());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getDesaKelurahan())) {
					alamat.setDesaKelurahan(
							desaKelurahanConverter.transferVOToModel(vo.getDesaKelurahan(), new DesaKelurahan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKecamatan())) {
					alamat.setKecamatan(kecamatanConverter.transferVOToModel(vo.getKecamatan(), new Kecamatan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKotaKabupaten())) {
					alamat.setKotaKabupaten(
							KotaKabupatenConverter.transferVOToModel(vo.getKotaKabupaten(), new KotaKabupaten()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getPropinsi())) {
					alamat.setPropinsi(propinsiConverter.transferVOToModel(vo.getPropinsi(), new Propinsi()));
				}
			}
		} else {
			Alamat alamat = new Alamat();
			if (CommonUtil.isNotNullOrEmpty(vo.getAlamatLengkap())) {
				alamat.setAlamatLengkap(vo.getAlamatLengkap());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getKodePos())) {
				alamat.setKodePos(vo.getKodePos());
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getDesaKelurahan())) {
				alamat.setDesaKelurahan(
						desaKelurahanConverter.transferVOToModel(vo.getDesaKelurahan(), new DesaKelurahan()));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getKecamatan())) {
				alamat.setKecamatan(kecamatanConverter.transferVOToModel(vo.getKecamatan(), new Kecamatan()));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getKotaKabupaten())) {
				alamat.setKotaKabupaten(
						KotaKabupatenConverter.transferVOToModel(vo.getKotaKabupaten(), new KotaKabupaten()));
			}
			if (CommonUtil.isNotNullOrEmpty(vo.getPropinsi())) {
				alamat.setPropinsi(propinsiConverter.transferVOToModel(vo.getPropinsi(), new Propinsi()));
			}
			if (CommonUtil.isNotNullOrEmpty(alamat)) {
				Set<Alamat> alamatSet = new HashSet<>();
				alamatSet.add(alamat);

				if (CommonUtil.isNotNullOrEmpty(alamatSet)) {
					pasien.setAlamats(alamatSet);
				}
			}
		}

		if (CommonUtil.isNotNullOrEmpty(pasien)) {
			Pasien pasienResult = pasienDao.save(pasien);
			result.put("id", pasienResult.getId());
		}
		return result;
	}

	/*
	 * public void checkNoRegistrasi(String noRegistrasi, Date tglRegistrasi,
	 * PasienDaftar pasienDaftar) { List<String> listNoreg =
	 * pasienDaftarDao.getNoRegistrasi(noRegistrasi); if
	 * (CommonUtil.isNotNullOrEmpty(listNoreg)) { String noRegMax =
	 * pasienDaftarService.getFormatNumberByMonthYearByParameter(tglRegistrasi);
	 * pasienDaftar.setNoRegistrasi(noRegMax); List<String> listNoreg2 =
	 * pasienDaftarDao.getNoRegistrasi(pasienDaftar.getNoRegistrasi()); if
	 * (listNoreg2.size() > 1) {
	 * checkNoRegistrasi(pasienDaftar.getNoRegistrasi(), tglRegistrasi,
	 * pasienDaftar); } } }
	 */

	public String secondCheckNoRegistrasi(PasienDaftar pasienDaftar) {
		List<String> listNoreg = pasienDaftarDao.getNoRegistrasi(pasienDaftar.getNoRegistrasi());
		String noRegMax = "";
		if (listNoreg.size() > 1) {
			noRegMax = pasienDaftarService.getFormatNumberByMonthYearByParameter(pasienDaftar.getTglRegistrasi());
			pasienDaftar.setNoRegistrasi(noRegMax);
			pasienDaftarDao.save(pasienDaftar);
		}
		return noRegMax;
	}

	public Map<String, Object> checkPasienPerjanjian(Integer pasienId, Integer ruanganId) {
		String status = "";
		Map<String, Object> result = new HashMap<String, Object>();
		PasienInstruksiPerjanjianT model = pasienInstruksiDao.findPapInstruksiPerjanjianByNoCm(pasienId);
		String ruangan = pelayananPasienDao.getSettingDataFixed("KdRuanganRehabilitasiMedik");
		if (ruanganId == Integer.valueOf(ruangan)) {
			if (CommonUtil.isNotNullOrEmpty(model)) {
				if(CommonUtil.isNotNullOrEmpty(model.getJumlahKunjungan()))
				{
					if (model.getJumlahKunjungan() > 0) {
						model.setJumlahKunjungan(model.getJumlahKunjungan() - 1);
						model = pasienInstruksiDao.save(model);
						result.put("noRec", model.getNoRec());
					}
				}
			}
		} else {
			if (CommonUtil.isNotNullOrEmpty(model)) {
				if(CommonUtil.isNotNullOrEmpty(model.getJumlahKunjungan()))
				{
					if (model.getJumlahKunjungan() > 0) {
						model.setJumlahKunjungan(model.getJumlahKunjungan() - 1);
						model = pasienInstruksiDao.save(model);
						result.put("noRec", model.getNoRec());
					} else if (model.getJumlahKunjungan() < 0) {
						status = "Pasien harus mendaftar ke Rehabilitasi Medik terlebih dahulu";
					}
				}
			} else {
				status = "Pasien harus mendaftar ke Rehabilitasi Medik terlebih dahulu";
			}
		}
		result.put("status", status);
		return result;
	}

	@Override
	public Map<String, Object> getDataRegistrasiPelayanan(String noRec) {
		Map<String, Object> result = new HashMap<String, Object>();
		PasienDaftar pasienDaftar = pasienDaftarDao.findOne(noRec);
		List<RegistrasiPelayananPasien> registrasiPelayananPasiens = registrasiPelayananPasienDao
				.finByNoRecPasiendaftar(noRec);
		List<AntrianPasienDiPeriksa> listAntrian = antrianPasienDiPeriksaDao.findByNoRecPasienDaftar(noRec);
		PemakaianAsuransi pemakaianAsuransi = pemakaianAsuransiDao.findByPasienDaftar(noRec);
		result.put("norecPasienDaftar", noRec);
		result.put("noRecAntrianPasienDiperiksa", "");
		try {
			if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
					result.put("pasien", pasienDaftar.getPasien().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
					result.put("ruangan", pasienDaftar.getRuangan().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKelompokPasien())) {
					result.put("kelompokPasien", pasienDaftar.getKelompokPasien().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getDokterPenanggungJawab())) {
					result.put("dokterPenanggungJawab", pasienDaftar.getDokterPenanggungJawab().ToMap());
				} else {
					result.put("dokterPenanggungJawab", "");
				}
				if (CommonUtil.isNotNullOrEmpty(listAntrian)) {
					result.put("noRecAntrianPasienDiperiksa", listAntrian.get(0).getNoRec());
					if (CommonUtil.isNotNullOrEmpty(listAntrian.get(0).getAsalRujukan())) {
						result.put("asalRujukan", listAntrian.get(0).getAsalRujukan().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(listAntrian.get(0).getKamar())) {
						result.put("kamar", listAntrian.get(0).getKamar().ToMap());
					}
					if (CommonUtil.isNotNullOrEmpty(listAntrian.get(0).getKelas())) {
						result.put("kelas", listAntrian.get(0).getKelas().ToMap());
					}
				}
				result.put("jenisLayanan", pasienDaftar.getJenisPelayanan());
				result.put("tglRegistrasi", pasienDaftar.getTglRegistrasi());
			}
			if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasiens)) {
				RegistrasiPelayananPasien registrasiPelayananPasien = registrasiPelayananPasiens.get(0);
				if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien.getAsalRujukan())) {
					result.put("asalRujukan", registrasiPelayananPasien.getAsalRujukan().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien.getKamar())) {
					result.put("kamar", registrasiPelayananPasien.getKamar().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien.getKelas())) {
					result.put("kelas", registrasiPelayananPasien.getKelas().ToMap());
				}
				if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien.getTempatTidur())) {
					result.put("tempatTidur", registrasiPelayananPasien.getTempatTidur().ToMap());
				}
			}
			if (CommonUtil.isNotNullOrEmpty(pemakaianAsuransi)) {
				Map<String, Object> asuransi = new HashMap<String, Object>();
				asuransi.put("pemakaianAsuransi", pemakaianAsuransi.ToMap());
				if (CommonUtil.isNotNullOrEmpty(pemakaianAsuransi.getAsuransiPasien())) {
					AsuransiPasien asuransiPasien = pemakaianAsuransi.getAsuransiPasien();
					if (CommonUtil.isNotNullOrEmpty(asuransiPasien)) {
						asuransi.put("asuransiPasien", asuransiPasien.ToMap());
					}
				}
				result.put("asuransi", asuransi);
			}

		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	public Map<String, Object> editPasienDaftar(RegistrasiPelayananVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<StrukPelayanan> strukPelayanan = strukPelayananDao.getStrukPelayanan(vo.getNoRecPasienDaftar());
		if (CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			result.put("statusPasien", "Pasien tidak dapat di edit");
			return result;
		} else {

			String KdDepartemenInstalasiRawatJalan = pelayananPasienDao
					.getSettingDataFixed("KdDepartemenInstalasiRawatJalan");

			String KdDepartemenInstalasiRehabilitasiMedik = pelayananPasienDao
					.getSettingDataFixed("KdDepartemenInstalasiRehabilitasiMedik");

			String KdDepartemenInstalasiGawatDarurat = pelayananPasienDao
					.getSettingDataFixed("KdDepartemenInstalasiGawatDarurat");

			String KdDepartemenInstalasiRawatInap = pelayananPasienDao
					.getSettingDataFixed("KdDepartemenInstalasiRawatInap");

			String KdInstalasiICU = pelayananPasienDao.getSettingDataFixed("KdInstalasiICU");

			String KdDepartemenInstalasiPeristi = pelayananPasienDao
					.getSettingDataFixed("KdDepartemenInstalasiPeristi");

			Kelas nonKelas = kelasDao.findNonKelas();
			AntrianPasienDiPeriksa antrianPasienDiPeriksa = null;

			Integer instalasiRawatJalan = Integer.parseInt(KdDepartemenInstalasiRawatJalan);
			Integer instalasiRehabilitasiMedik = Integer.parseInt(KdDepartemenInstalasiRehabilitasiMedik);
			Integer instalasiGawatDarurat = Integer.parseInt(KdDepartemenInstalasiGawatDarurat);
			Integer instalasiRawatInap = Integer.parseInt(KdDepartemenInstalasiRawatInap);
			Integer instalasiICU = Integer.parseInt(KdInstalasiICU);
			Integer instalasiPeristi = Integer.parseInt(KdDepartemenInstalasiPeristi);

			if (CommonUtil.isNotNullOrEmpty(vo)) {
				PasienDaftar pasienDaftar = pasienDaftarDao.findByNoRec(vo.getNoRecPasienDaftar());
				pasienDaftar.setNoRec(vo.getNoRecPasienDaftar());
				if (CommonUtil.isNotNullOrEmpty(vo.getJenisPelayanan())) {
					pasienDaftar.setJenisPelayanan(vo.getJenisPelayanan());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
					pasienDaftar.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
					Integer hitungBilik = ruanganDao.countRuanganBilik(vo.getRuangan().getId());
					if (hitungBilik == 0) {
						pasienDaftar.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
					} else {
						Ruangan r = findRuanganBilik(vo.getRuangan().getId(), vo.getTglRegistrasi());
						pasienDaftar.setRuangan(r);
					}
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKasusPenyakit())) {
					pasienDaftar.setKasusPenyakit(
							kasusPenyakitConverter.transferVOToModel(vo.getKasusPenyakit(), new KasusPenyakit()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getPasien())) {
					pasienDaftar.setPasien(pasienConverter.transferVOToModel(vo.getPasien(), new Pasien()));

					Integer countKasusPenyakit = pasienDaftarDao
							.checkStatuspasien(pasienDaftar.getKasusPenyakit().getId());
					if (countKasusPenyakit == 0 || countKasusPenyakit == null) {
						pasienDaftar.setStatusKasusPenyakit(true);
					} else {
						pasienDaftar.setStatusKasusPenyakit(false);
					}
				}
				KelompokPasien kelompokPasien = kelompokPasienDao.defaultKelompokPasien();
				if (CommonUtil.isNotNullOrEmpty(vo.getKelompokPasien())) {
					pasienDaftar.setKelompokPasien(
							kelompokPasienConverter.transferVOToModel(vo.getKelompokPasien(), new KelompokPasien()));

					if (vo.getKelompokPasien().getId() == kelompokPasien.getId()) {
						PemakaianAsuransi pemakaianAsuransi = pemakaianAsuransiDao
								.findByPasienDaftar(vo.getNoRecPasienDaftar());
						if (CommonUtil.isNotNullOrEmpty(pemakaianAsuransi)) {
							/* PasienDaftar model = new PasienDaftar(); */
							// pemakaianAsuransi.setPasienDaftar(null);
							pemakaianAsuransiDao.delete(pemakaianAsuransi);
						}
					}
				} else {
					pasienDaftar.setKelompokPasien(kelompokPasien);
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getIsOnSiteService())) {
					pasienDaftar.setIsOnSiteService(vo.getIsOnSiteService());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getIsRegistrasiLengkap())) {
					pasienDaftar.setIsRegistrasiLengkap(vo.getIsRegistrasiLengkap());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getTglRegistrasi())) {
					pasienDaftar.setTglRegistrasi(vo.getTglRegistrasi());
				}

				if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					pasienDaftar.setDokterPenanggungJawab(
							pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getEmergensi())) {
					pasienDaftar.setEmergensi(vo.getEmergensi());
				}

				Set<AntrianPasienDiPeriksa> antrianPasienDiPeriksaSet = new HashSet<>();
				if (CommonUtil.isNotNullOrEmpty(vo.getNoRecAntrianPasien())) {
					antrianPasienDiPeriksa = antrianPasienDiPeriksaDao.findByNoRec(vo.getNoRecAntrianPasien());
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						antrianPasienDiPeriksa
								.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {

						Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());

						if (ruangan.getDepartemenId() == instalasiRawatInap || ruangan.getDepartemenId() == instalasiICU
								|| ruangan.getDepartemenId() == instalasiPeristi) {
							if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
								antrianPasienDiPeriksa
										.setKelas(kelasConverter.transferVOToModel(vo.getKelas(), new Kelas()));
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getKamar())) {
								antrianPasienDiPeriksa
										.setKamar(kamarConverter.transferVOToModel(vo.getKamar(), new Kamar()));
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getRawatGabung())) {
								antrianPasienDiPeriksa.setIsRawatGabung(vo.getRawatGabung());
							}
							if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
								antrianPasienDiPeriksa.setNoBed(vo.getNomorTempatTidur().getId());
							}
							if (CommonUtil.isNotNullOrEmpty(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
								antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.getVal());
							}
						} else {
							if (CommonUtil.isNotNullOrEmpty(nonKelas)) {
								antrianPasienDiPeriksa.setKelas(nonKelas);
							}
							if (CommonUtil.isNotNullOrEmpty(StatusAntrianEnum.MENUNGGU.getVal())) {
								antrianPasienDiPeriksa.setNoMasuk(StatusAntrianEnum.MENUNGGU.getVal());
								antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MENUNGGU.getVal());
							}
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
						antrianPasienDiPeriksa.setAsalRujukan(
								asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
						antrianPasienDiPeriksa
								.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						antrianPasienDiPeriksa
								.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
							antrianPasienDiPeriksa.setNoAntrian(antrianPasienDiPeriksaService
									.getFormatNumberByMonthYearBilik(pasienDaftar.getRuangan().getId()));
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getTglRegistrasi())) {
						antrianPasienDiPeriksa.setTglRegistrasi(vo.getTglRegistrasi());
					}
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar)) {
						antrianPasienDiPeriksa.setPasienDaftar(pasienDaftar);
					}
					if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
						antrianPasienDiPeriksaSet.add(antrianPasienDiPeriksa);
					}
				}
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksaSet)) {
					pasienDaftar.setAntrianPasienDiPeriksaSet(antrianPasienDiPeriksaSet);
				}
				/*
				 * ------------------SAVE PASIEN DAFTAR------------------
				 */
				if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
					if (CommonUtil.isNotNullOrEmpty(vo.getJenisPelayanan())) {
						pasienDaftar.setJenisPelayanan(vo.getJenisPelayanan());
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						if (vo.getRuangan().getDepartemenId() == instalasiRawatJalan
								|| vo.getRuangan().getDepartemenId() == instalasiRehabilitasiMedik
								|| vo.getRuangan().getDepartemenId() == instalasiGawatDarurat) {

							pasienDaftar.setTglPulang(pasienDaftar.getTglRegistrasi());
							pasienDaftar.setKelas(nonKelas);
						} else if (vo.getRuangan().getDepartemenId() == instalasiRawatInap) {
							if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
								pasienDaftar.setTglPulang(null);
								pasienDaftar
										.setKelas(BaseConverterImpl.transferVOToModelData(vo.getKelas(), new Kelas()));
							}
						}
					}
				}

				PasienDaftar passienDaftarResult = pasienDaftarDao.save(pasienDaftar);
				List<RegistrasiPelayananPasien> registrasiPelayananPasiens = registrasiPelayananPasienDao
						.finByNoRecPasiendaftar(pasienDaftar.getNoRec());
				RegistrasiPelayananPasien registrasiPelayananPasien = new RegistrasiPelayananPasien();
				if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasiens)) {
					registrasiPelayananPasien = registrasiPelayananPasiens.get(0);
				}
				if (CommonUtil.isNotNullOrEmpty(passienDaftarResult)) {
					result.put("noRec", pasienDaftar.getNoRec());
					result.put("noRecAntrian", antrianPasienDiPeriksa.getNoRec());
					result.put("noRegistrasi", pasienDaftar.getNoRegistrasi());
					result.put("noAntrian", antrianPasienDiPeriksa.getNoAntrian());
					if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
						result.put("noCm", pasienDaftar.getPasien().getNoCm());
					}

					if (passienDaftarResult.getRuangan().getDepartemenId() == instalasiRawatInap
							|| passienDaftarResult.getRuangan().getDepartemenId() == instalasiICU
							|| passienDaftarResult.getRuangan().getDepartemenId() == instalasiPeristi) {

						if (CommonUtil.isNullOrEmpty(registrasiPelayananPasien)) {
							registrasiPelayananPasien = new RegistrasiPelayananPasien();
						}
						registrasiPelayananPasien.setPasienDaftar(pasienDaftar);
						Kamar kamar = kamarDao.findOne(vo.getKamar().getId());

						if (CommonUtil.isNotNullOrEmpty(kamar)) {
							Integer jumlahKamarIsi = kamar.getJumlaKamarIsi() + 1;
							if (CommonUtil.isNotNullOrEmpty(jumlahKamarIsi)) {
								kamar.setJumlaKamarIsi(jumlahKamarIsi);
							}
							Integer jumlahKamarKosong = kamar.getJumlaKamarKosong() - 1;
							if (CommonUtil.isNotNullOrEmpty(jumlahKamarKosong)) {
								kamar.setJumlaKamarKosong(jumlahKamarKosong);
							}
							if (CommonUtil.isNotNullOrEmpty(kamar) && vo.getRawatGabung().FALSE) {
								Kamar resultKamar = kamarDao.save(kamar);
								if (CommonUtil.isNotNullOrEmpty(resultKamar)
										&& CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
									tambahKamarKosong(registrasiPelayananPasien.getKamarId(), result);
								}
							}
							registrasiPelayananPasien.setKamar(kamar);
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
							TempatTidur tempatTidur = tempatTidurDao.findOne(vo.getNomorTempatTidur().getId());
							StatusBed statusBed = new StatusBed();
							statusBed.setId(1);

							if (CommonUtil.isNotNullOrEmpty(tempatTidur) && vo.getRawatGabung().FALSE) {
								tempatTidur.setStatusBed(statusBed);
								TempatTidur resultTempatTidur = tempatTidurDao.save(tempatTidur);
								if (CommonUtil.isNotNullOrEmpty(resultTempatTidur)
										&& CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
									tambahBedKosong(registrasiPelayananPasien.getTempatTidur().getId(), result);
									registrasiPelayananPasien.setTempatTidur(tempatTidur);
								}
							}
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getAsalRujukan())) {
							registrasiPelayananPasien.setAsalRujukan(
									asalRujukanConverter.transferVOToModel(vo.getAsalRujukan(), new AsalRujukan()));
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKasusPenyakit())) {
							registrasiPelayananPasien.setKasusPenyakit(pasienDaftar.getKasusPenyakit());
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
							registrasiPelayananPasien.setKdDokter(vo.getPegawai().getNoRec());
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
							registrasiPelayananPasien
									.setKelas(kelasConverter.transferVOToModel(vo.getKelas(), new Kelas()));
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getKelompokPasien())) {
							registrasiPelayananPasien.setKelompokPasien(pasienDaftar.getKelompokPasien());
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getRuangan())) {
							registrasiPelayananPasien.setRuangan(pasienDaftar.getRuangan());
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
							registrasiPelayananPasien.setPasien(pasienDaftar.getPasien());
						}
						if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getTglRegistrasi())) {
							registrasiPelayananPasien.setTglMasuk(pasienDaftar.getTglRegistrasi());
						}
						if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
							registrasiPelayananPasienDao.save(registrasiPelayananPasien);
						}
						// added akomodasi to pelayanan pasien and pelayanan
						// pasien detail -->added by susy
						/*Map<String, Object> pelayananPasien = saveAkomodasi(antrianPasienDiPeriksa, vo.getRawatGabung(),
								false, true);
						if (CommonUtil.isNotNullOrEmpty(pelayananPasien)) {
							result.putAll(pelayananPasien);
						}*/
					}
				}
			}

			return result;
		}
	}

	@Override
	public void tambahKamarKosong(Integer id, Map<String, Object> result) {
		Kamar kamar = kamarDao.findOne(id);

		if (CommonUtil.isNotNullOrEmpty(kamar)) {
			Integer jumlahKamarIsi = kamar.getJumlaKamarIsi() - 1;
			if (CommonUtil.isNotNullOrEmpty(jumlahKamarIsi)) {
				kamar.setJumlaKamarIsi(jumlahKamarIsi);
			}
			Integer jumlahKamarKosong = kamar.getJumlaKamarKosong() + 1;
			if (CommonUtil.isNotNullOrEmpty(jumlahKamarKosong)) {
				kamar.setJumlaKamarKosong(jumlahKamarKosong);
			}
			if (CommonUtil.isNotNullOrEmpty(kamar)) {
				Kamar model = kamarDao.save(kamar);
				result.put("idKamarLama", model.getId());
			}
		}
	}

	@Override
	public void tambahBedKosong(Integer id, Map<String, Object> result) {
		TempatTidur tempatTidur = tempatTidurDao.findOne(id);
		if (CommonUtil.isNotNullOrEmpty(tempatTidur)) {
			StatusBed statusBed = new StatusBed();
			statusBed.setId(2);

			if (CommonUtil.isNotNullOrEmpty(statusBed)) {
				tempatTidur.setStatusBed(statusBed);
			}
			if (CommonUtil.isNotNullOrEmpty(statusBed)) {
				TempatTidur model = tempatTidurDao.save(tempatTidur);
				result.put("idTempatTidurLama", model.getId());
			}
		}
	}

	@Override
	public Map<String, Object> editAsuransiPasien(AsuransiRegistrasiPasienVO vos) {
		Map<String, Object> result = new HashMap<>();

		AsuransiPasienVO vo = vos.getAsuransiPasien();
		if (CommonUtil.isNotNullOrEmpty(vo)) {
			AsuransiPasien asuransiPasien = asuransiPasienDao.getAsuransiByPasien(vo.getNoAsuransi(),
					vo.getNoCm().getId());

			if (CommonUtil.isNotNullOrEmpty(asuransiPasien)) {

				if (CommonUtil.isNotNullOrEmpty(vo.getJenisPeserta())) {
					asuransiPasien.setJenisPeserta(vo.getJenisPeserta());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getGolonganAsuransi())) {
					asuransiPasien.setGolonganAsuransi(golonganAsuransiConverter
							.transferVOToModel(vo.getGolonganAsuransi(), new GolonganAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getHubunganPeserta())) {
					asuransiPasien.setHubunganPeserta(hubunganPesertaAsuransiConverter
							.transferVOToModel(vo.getHubunganPeserta(), new HubunganPesertaAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKelasDiJamin())) {
					asuransiPasien.setKelasDiJamin(kelasConverter.transferVOToModel(vo.getKelasDiJamin(), new Kelas()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					asuransiPasien.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
					asuransiPasien.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getJenisPeserta())) {
					asuransiPasien.setJenisPeserta(vo.getJenisPeserta());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNmProvider())) {
					asuransiPasien.setNmProvider(vo.getNmProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKdProvider())) {
					asuransiPasien.setKdProvider(vo.getKdProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNoCm())) {
					asuransiPasien.setNoCm(pasienConverter.transferVOToModel(vo.getNoCm(), new Pasien()));
				}
				Map<String, Object> registrasi = editPasienDaftar(vos.getRegistrasiPelayanan());
				result.putAll(registrasi);
				if (CommonUtil.isNotNullOrEmpty(registrasi)) {
					if (CommonUtil.isNotNullOrEmpty(registrasi.get("statusPasien"))) {
						result.put("statusPasien", registrasi.get("statusPasien"));
					} else {
						AsuransiPasien asuransiPasienResult = asuransiPasienDao.save(asuransiPasien);
						if (CommonUtil.isNotNullOrEmpty(asuransiPasienResult)) {
							Map<String, Object> pemakaianAsuransi = savePemakaianAsuransi(asuransiPasien, vos,
									registrasi);
							result.putAll(pemakaianAsuransi);
						}
						if (CommonUtil.isNotNullOrEmpty(vo.getNoSep())
								&& CommonUtil.isNotNullOrEmpty(registrasi.get("noRegistrasi"))) {
							Map<String, Object> mapping = bridgingBpjs.mappingTransaksiSep(vo.getNoSep(),
									registrasi.get("noRegistrasi") + "");
							result.put("response", mapping.get("response"));
						}
					}
				}
			} else {
				AsuransiPasien asuransiPasienNew = asuransiPasienConverter.transferVOToModel(vo, new AsuransiPasien());
				if (CommonUtil.isNotNullOrEmpty(vo.getGolonganAsuransi())) {
					asuransiPasienNew.setGolonganAsuransi(golonganAsuransiConverter
							.transferVOToModel(vo.getGolonganAsuransi(), new GolonganAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getHubunganPeserta())) {
					asuransiPasienNew.setHubunganPeserta(hubunganPesertaAsuransiConverter
							.transferVOToModel(vo.getHubunganPeserta(), new HubunganPesertaAsuransi()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKelasDiJamin())) {
					asuransiPasienNew
							.setKelasDiJamin(kelasConverter.transferVOToModel(vo.getKelasDiJamin(), new Kelas()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getPegawai())) {
					asuransiPasienNew.setPegawai(pegawaiConverter.transferVOToModel(vo.getPegawai(), new Pegawai()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getRekanan())) {
					asuransiPasienNew.setRekanan(rekananConverter.transferVOToModel(vo.getRekanan(), new Rekanan()));
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getJenisPeserta())) {
					asuransiPasienNew.setJenisPeserta(vo.getJenisPeserta());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNmProvider())) {
					asuransiPasienNew.setNmProvider(vo.getNmProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getKdProvider())) {
					asuransiPasienNew.setKdProvider(vo.getKdProvider());
				}
				if (CommonUtil.isNotNullOrEmpty(vo.getNoCm())) {
					asuransiPasienNew.setNoCm(pasienConverter.transferVOToModel(vo.getNoCm(), new Pasien()));
				}
				if (CommonUtil.isNotNullOrEmpty(asuransiPasienNew)) {
					Map<String, Object> registrasi = editPasienDaftar(vos.getRegistrasiPelayanan());

					if (CommonUtil.isNotNullOrEmpty(registrasi)) {
						if (CommonUtil.isNotNullOrEmpty(registrasi.get("statusPasien"))) {
							result.put("statusPasien", registrasi.get("statusPasien"));
						} else {
							AsuransiPasien asuransiPasienResult = asuransiPasienDao.save(asuransiPasienNew);
							if (CommonUtil.isNotNullOrEmpty(asuransiPasienResult)) {
								Map<String, Object> pemakaianAsuransi = savePemakaianAsuransi(asuransiPasienNew, vos,
										registrasi);
								result.putAll(pemakaianAsuransi);
								result = registrasi;
								if (CommonUtil.isNotNullOrEmpty(vo.getNoSep())
										&& CommonUtil.isNotNullOrEmpty(registrasi.get("noRegistrasi"))) {
									Map<String, Object> mapping = bridgingBpjs.mappingTransaksiSep(vo.getNoSep(),
											registrasi.get("noRegistrasi") + "");
									result.put("response", mapping.get("response"));
								}

							}
						}
					}
				}
			}
		}
		return result;
	}

	@Override
	public List<DiagnosaVO> findDiagnosaByKode(String kodeDiagnosa) {
		List<DiagnosaVO> data = new ArrayList<DiagnosaVO>();
		diagnosaConverter.setUseGson(false);
		List<Diagnosa> page = diagnosaDao.findDiagnosaByKode(kodeDiagnosa, new PageRequest(0, 1));// produkDao.findObatByNama(namaObat,new
																									// PageRequest(0,25));

		return diagnosaConverter.transferListOfModelToListOfVO(page, data, DiagnosaVO.class);
	}

	@Override
	public Map<String, Object> getListProduk(Integer idKelas) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<Map<String, Object>> listDatamapping = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listData = hargaNettoProdukByKelasDao.getListprodukInMapping();

		for (Map<String, Object> data : listData) {
			if (CommonUtil.isNotNullOrEmpty(data.get("kelasId"))) {
				if ((Integer) data.get("kelasId") != idKelas) {
					listDatamapping.add(data);
				}
			}
		}
		result.put("mapping", listDatamapping);
		return result;
	}

	@Override
	public List<Map<String, Object>> getListAntrian(String noCm, String startDate, String endDate) {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> rawatInap = antrianPasienDiPeriksaDaoCustom.findAllAntrianByNocm(noCm, startDate,
				endDate, true);
		rawatInap = checkRuanganAsalStatus(rawatInap);
		List<Map<String, Object>> rawatJalan = antrianPasienDiPeriksaDaoCustom.findAllAntrianByNocm(noCm, startDate,
				endDate, false);
		rawatJalan = checkRuanganAsalStatus(rawatJalan);
		result.addAll(rawatInap);
		result.addAll(rawatJalan);
		return result;
	}

	public List<Map<String, Object>> checkRuanganAsalStatus(List<Map<String, Object>> datas) {
		for (Map<String, Object> data : datas) {
			if (CommonUtil.isNotNullOrEmpty(data.get("idRuanganAsal"))
					&& CommonUtil.isNotNullOrEmpty(data.get("idRuangan"))) {
				if ((Integer) data.get("idRuanganAsal") == (Integer) data.get("idRuangan")) {
					data.put("ruanganAsal", true);
				} else {
					data.put("ruanganAsal", false);
				}
			} else {
				data.put("ruanganAsal", false);
			}
			if (CommonUtil.isNotNullOrEmpty(data.get("idRuanganLast"))
					&& CommonUtil.isNotNullOrEmpty(data.get("idRuangan"))) {
				if ((Integer) data.get("idRuanganLast") == (Integer) data.get("idRuangan")) {
					data.put("ruanganLast", true);
				} else {
					data.put("ruanganLast", false);
				}

			} else {
				data.put("ruanganLast", false);
			}
		}
		return datas;
	}

	@Override
	public Map<String, Object> findAllKendaliDokumenRekamMedis(String noCm, String start, String end, String ruangan,
			Integer idStatus) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<KendaliDokumenRekamMedis> listData = antrianPasienDiPeriksaDaoCustom.findAllKendaliDokumenRekamMedis(noCm,
				convertDate(start), convertDate(end), ruangan, idStatus);
		List<Map<String, Object>> datas = antrianPasienDiPeriksaDaoCustom.findCountKendaliDokumenRekamMedis(noCm,
				convertDate(start), convertDate(end), ruangan, idStatus);
		for (Map<String, Object> data : datas) {
			result.put(data.get("name") + "", data.get("count"));
		}
		try {
			List<Map<String, Object>> listDatas = JsonUtil.ToMaps(listData);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
			for (Map<String, Object> map : listDatas) {
				if (CommonUtil.isNotNullOrEmpty(map.get("tglUpdate"))) {
					Date tglUpdate = (Date) map.get("tglUpdate");
					map.put("tglUpdate", sdf.format(tglUpdate));
				}
				if (CommonUtil.isNotNullOrEmpty(map.get("tglKembali"))) {
					Date tglKembali = (Date) map.get("tglKembali");
					map.put("tglKembali", sdf.format(tglKembali));
				}
			}
			result.put("data", listDatas);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@SuppressWarnings("unchecked")
	@Override
	public Map<String, Object> saveDetailSep(Map<String, Object> dataSep) {
		Map<String, Object> result = new HashMap<String, Object>();
		DetailSep detailSep = new DetailSep();
		if (CommonUtil.isNotNullOrEmpty(dataSep)) {
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("byTagihan"))) {
				detailSep.setByTagihan(dataSep.get("byTagihan") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("catatan"))) {
				detailSep.setCatatan(dataSep.get("catatan") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("diagAwal"))) {
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("diagAwal")).get("kdDiag"))) {
					detailSep.setKdDiag(((Map<String, Object>) dataSep.get("diagAwal")).get("kdDiag") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("diagAwal")).get("nmDiag"))) {
					detailSep.setNmDiag(((Map<String, Object>) dataSep.get("diagAwal")).get("nmDiag") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("jnsPelayanan"))) {
				detailSep.setJnsPelayanan(dataSep.get("jnsPelayanan") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("klsRawat"))) {
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("klsRawat")).get("kdKelas"))) {
					detailSep.setKdKelasRawat(((Map<String, Object>) dataSep.get("klsRawat")).get("kdKelas") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("klsRawat")).get("nmKelas"))) {
					detailSep.setNmKelasRawat(((Map<String, Object>) dataSep.get("klsRawat")).get("nmKelas") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("lakaLantas"))) {
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("lakaLantas")).get("keterangan"))) {
					detailSep.setKeterangan(((Map<String, Object>) dataSep.get("lakaLantas")).get("keterangan") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(((Map<String, Object>) dataSep.get("lakaLantas")).get("status"))) {
					detailSep.setStatus(((Map<String, Object>) dataSep.get("lakaLantas")).get("status") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("noRujukan"))) {
				detailSep.setNoRujukan(dataSep.get("noRujukan") + "");
			}

			if (CommonUtil.isNotNullOrEmpty(dataSep.get("noSep"))) {
				detailSep.setNoSep(dataSep.get("noSep") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("peserta"))) {
				Map<String, Object> peserta = (Map<String, Object>) dataSep.get("peserta");
				if (CommonUtil.isNotNullOrEmpty(peserta.get("jenisPeserta"))) {
					Map<String, Object> jenisPeserta = (Map<String, Object>) peserta.get("jenisPeserta");
					if (CommonUtil.isNotNullOrEmpty(jenisPeserta.get("kdJenisPeserta"))) {
						detailSep.setKdJenisPeserta(jenisPeserta.get("kdJenisPeserta") + "");
					}
					if (CommonUtil.isNotNullOrEmpty(jenisPeserta.get("nmJenisPeserta"))) {
						detailSep.setNmJenisPeserta(jenisPeserta.get("nmJenisPeserta") + "");
					}
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("kelasTanggungan"))) {
					Map<String, Object> kelasTanggungan = (Map<String, Object>) peserta.get("kelasTanggungan");
					if (CommonUtil.isNotNullOrEmpty(kelasTanggungan.get("kdKelas"))) {
						detailSep.setKdKelasTanggungan(kelasTanggungan.get("kdKelas") + "");
					}
					if (CommonUtil.isNotNullOrEmpty(kelasTanggungan.get("nmKelas"))) {
						detailSep.setNmKelasTanggungan(kelasTanggungan.get("nmKelas") + "");
					}
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("provUmum"))) {
					Map<String, Object> provUmum = (Map<String, Object>) peserta.get("provUmum");
					if (CommonUtil.isNotNullOrEmpty(provUmum.get("kdCabang"))) {
						detailSep.setKdCabangUmum(provUmum.get("kdCabang") + "");
					}
					if (CommonUtil.isNotNullOrEmpty(provUmum.get("kdProvider"))) {
						detailSep.setKdProviderUmum(provUmum.get("kdProvider") + "");
					}
					if (CommonUtil.isNotNullOrEmpty(provUmum.get("nmCabang"))) {
						detailSep.setNmCabangUmum(provUmum.get("nmCabang") + "");
					}
					if (CommonUtil.isNotNullOrEmpty(provUmum.get("nmProvider"))) {
						detailSep.setNmProviderUmum(provUmum.get("nmProvider") + "");
					}
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("informasi"))) {
					detailSep.setInformasi(peserta.get("informasi") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("nama"))) {
					detailSep.setNama(peserta.get("nama") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("nik"))) {
					detailSep.setNik(peserta.get("nik") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("noKartu"))) {
					detailSep.setNoKartu(peserta.get("noKartu") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("noMr"))) {
					detailSep.setNoMr(peserta.get("noMr") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("pisa"))) {
					detailSep.setPisa(peserta.get("pisa") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("sex"))) {
					detailSep.setSex(peserta.get("sex") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("statusPeserta"))) {
					detailSep.setStatusPeserta(peserta.get("statusPeserta") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("tglCetakKartu"))) {
					detailSep.setTglCetakKartu(peserta.get("tglCetakKartu") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("tglLahir"))) {
					detailSep.setTglLahir(peserta.get("tglLahir") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("tglTAT"))) {
					detailSep.setTglTAT(peserta.get("tglTAT") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("tglTMT"))) {
					detailSep.setTglTMT(peserta.get("tglTMT") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(peserta.get("umur"))) {
					detailSep.setTglTMT(peserta.get("umur") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("poliTujuan"))) {
				Map<String, Object> poliTujuan = (Map<String, Object>) dataSep.get("poliTujuan");
				if (CommonUtil.isNotNullOrEmpty(poliTujuan.get("kdPoli"))) {
					detailSep.setKdPoli(poliTujuan.get("kdPoli") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(poliTujuan.get("nmPoli"))) {
					detailSep.setNmPoli(poliTujuan.get("nmPoli") + "");
				}
			}

			if (CommonUtil.isNotNullOrEmpty(dataSep.get("provPelayanan"))) {
				Map<String, Object> provPelayanan = (Map<String, Object>) dataSep.get("provPelayanan");
				if (CommonUtil.isNotNullOrEmpty(provPelayanan.get("kdCabang"))) {
					detailSep.setKdCabangPelayanan(provPelayanan.get("kdCabang") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provPelayanan.get("kdProvider"))) {
					detailSep.setKdProviderPelayanan(provPelayanan.get("kdProvider") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provPelayanan.get("nmCabang"))) {
					detailSep.setNmCabangPelayanan(provPelayanan.get("nmCabang") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provPelayanan.get("nmProvider"))) {
					detailSep.setNmProviderPelayanan(provPelayanan.get("nmProvider") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("provRujukan"))) {

				Map<String, Object> provRujukan = (Map<String, Object>) dataSep.get("provRujukan");
				if (CommonUtil.isNotNullOrEmpty(provRujukan.get("kdCabang"))) {
					detailSep.setKdCabangRujukan(provRujukan.get("kdCabang") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provRujukan.get("kdProvider"))) {
					detailSep.setKdProviderRujukan(provRujukan.get("kdProvider") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provRujukan.get("nmCabang"))) {
					detailSep.setNmCabangRujukan(provRujukan.get("nmCabang") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(provRujukan.get("nmProvider"))) {
					detailSep.setNmProviderRujukan(provRujukan.get("nmProvider") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("statSep"))) {
				Map<String, Object> statSep = (Map<String, Object>) dataSep.get("statSep");
				if (CommonUtil.isNotNullOrEmpty(statSep.get("kdStatSep"))) {
					detailSep.setKetStatSep(statSep.get("kdStatSep") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(statSep.get("ketStatSep"))) {
					detailSep.setKetStatSep(statSep.get("ketStatSep") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(statSep.get("nmStatSep"))) {
					detailSep.setNmStatSep(statSep.get("nmStatSep") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("statusCOB"))) {
				Map<String, Object> statusCOB = (Map<String, Object>) dataSep.get("statusCOB");
				if (CommonUtil.isNotNullOrEmpty(statusCOB.get("kodeCOB"))) {
					detailSep.setKodeCOB(statusCOB.get("kodeCOB") + "");
				}
				if (CommonUtil.isNotNullOrEmpty(statusCOB.get("namaCOB"))) {
					detailSep.setNamaCOB(statusCOB.get("namaCOB") + "");
				}
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("tglPulang"))) {
				detailSep.setTglPulang(dataSep.get("tglPulang") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("tglRujukan"))) {
				detailSep.setTglRujukan(dataSep.get("tglRujukan") + "");
			}
			if (CommonUtil.isNotNullOrEmpty(dataSep.get("tglSep"))) {
				detailSep.setTglSep(dataSep.get("tglSep") + "");
			}
		}
		if (CommonUtil.isNotNullOrEmpty(detailSep)) {
			DetailSep model = detailSepDao.save(detailSep);
			if (CommonUtil.isNotNullOrEmpty(model)) {
				result.put("noRecDetailSep", model.getNoRec());
			}
		}
		return result;
	}

	@Override
	public Map<String, Object> saveAkomodasi(AntrianPasienDiPeriksa antrian, Boolean isRawatGabung, Boolean isNewDate,
			Boolean edit) {
		Map<String, Object> result = new HashMap<String, Object>();
		PelayananPasien pelayanan = new PelayananPasien();
		Set<PelayananPasienDetail> pelayananPasienDetailSet = new HashSet<>();
		String akomodasiRawatGabung = pelayananPasienDao.getSettingDataFixed("akomodasiRawatGabung");
		String jenisProdukAkomodasi = pelayananPasienDao.getSettingDataFixed("jenisProdukAkomodasi");
		Integer produkId = 0;
		List<Integer> listIdProduk = registrasiPelayananPasienDao.findIdProduk(antrian.getRuangan().getId(),
				Integer.valueOf(jenisProdukAkomodasi));
		listIdProduk.remove(Integer.valueOf(akomodasiRawatGabung));
		if (CommonUtil.isNotNullOrEmpty(listIdProduk)) {
			produkId = listIdProduk.get(0);
		}
		if (CommonUtil.isNotNullOrEmpty(isRawatGabung)) {
			if (isRawatGabung)
				produkId = Integer.valueOf(akomodasiRawatGabung);
		}
		List<String> data = antrianPasienDiPeriksaDaoCustom.checkDataRawatInapforAkomodasi(
				Integer.valueOf(jenisProdukAkomodasi), antrian.getPasienDaftar().getNoRec());
		if (edit)// jika edit is true then delete all pelayanan pasien and
					// detail then add the new one
		{
			for (String noRec : data) {
				PelayananPasien pp = pelayananPasienDao.findOne(noRec);
				if (CommonUtil.isNotNullOrEmpty(pp)) {
					if (pp.getKelasId() != antrian.getKelasId()) {
						pelayananPasienDao.delete(pp);
					}
				} else {
					return result;
				}
			}
		}
		Produk produk = produkDao.findById(produkId);
		if (CommonUtil.isNotNullOrEmpty(produk)) {
			pelayanan.setProduk(produk);
			if (isNewDate) {
				pelayanan.setTglPelayanan(new Date());
			} else {
				pelayanan.setTglPelayanan(antrian.getTglRegistrasi());
			}
			pelayanan.setKelas(antrian.getKelas());
			pelayanan.setPasien(antrian);// antrian
			Map<String, Object> mappingproduk = hargaNettoProdukByKelasDao.getProdukByKelas(antrian.getKelas().getId(),
					produk.getId());
			if (CommonUtil.isNotNullOrEmpty(mappingproduk)) {
				if (CommonUtil.isNotNullOrEmpty(mappingproduk.get("hargaSatuan"))) {
					pelayanan.setHargaJual((Double) mappingproduk.get("hargaSatuan"));
					pelayanan.setHargaSatuan((Double) mappingproduk.get("hargaSatuan"));
					pelayanan.setHargaNetto((Double) mappingproduk.get("hargaSatuan"));
				}
			}
			pelayanan.setPiutangRumahSakit(0.0);
			pelayanan.setPiutangPenjamin(0.0);
			pelayanan.setStock(1.0);
			pelayanan.setJumlah(1.0);
			List<HargaNettoProdukByKelasD> detail = hargaNettoProdukByKelasDDao
					.findByKelasNProduk(antrian.getKelas().getId(), produk.getId());
			for (HargaNettoProdukByKelasD hargaNetto : detail) {
				PelayananPasienDetail pelayananPasienDetail = new PelayananPasienDetail();
				if (CommonUtil.isNotNullOrEmpty(pelayanan)) {
					pelayananPasienDetail.setPelayananPasien(pelayanan);
					if (CommonUtil.isNotNullOrEmpty(hargaNetto.getProduk())) {
						pelayananPasienDetail.setProduk(hargaNetto.getProduk());
					}
					if (CommonUtil.isNotNullOrEmpty(antrian)) {
						pelayananPasienDetail.setPasien(antrian);
					}
					if (CommonUtil.isNotNullOrEmpty(hargaNetto.getKomponenHarga())) {
						pelayananPasienDetail.setKomponenHarga(hargaNetto.getKomponenHarga());
					}
					if (CommonUtil.isNotNullOrEmpty(pelayanan.getTglPelayanan())) {
						pelayananPasienDetail.setTglPelayanan(pelayanan.getTglPelayanan());
					}
					if (CommonUtil.isNotNullOrEmpty(hargaNetto.getHargaSatuan())) {
						pelayananPasienDetail.setHargaSatuan(hargaNetto.getHargaSatuan());
					}
					if (CommonUtil.isNotNullOrEmpty(pelayanan.getHargaJual())) {
						pelayananPasienDetail.setHargaJual(pelayanan.getHargaJual());
					}
					if (CommonUtil.isNotNullOrEmpty(hargaNetto.getHargaNetto1())) {
						pelayananPasienDetail.setHargaNetto(hargaNetto.getHargaNetto1());
					}
					if (CommonUtil.isNotNullOrEmpty(hargaNetto.getqtyCurrentStok())) {
						pelayananPasienDetail.setStock(hargaNetto.getqtyCurrentStok().intValue());
					}
					if (CommonUtil.isNotNullOrEmpty(pelayanan.getJumlah())) {
						pelayananPasienDetail.setJumlah(pelayanan.getJumlah());
					}
					if (CommonUtil.isNotNullOrEmpty(pelayananPasienDetail)) {
						pelayananPasienDetailSet.add(pelayananPasienDetail);
					}
				}
			}
			pelayanan.setPelayananPasienDetailSet(pelayananPasienDetailSet);
			if (CommonUtil.isNullOrEmpty(data))// jika tidak ada data akomodasi
												// untuk hari ini.
			{
				if (CommonUtil.isNotNullOrEmpty(pelayanan)) {
					PelayananPasien model = pelayananPasienDao.save(pelayanan);
					result.put("noRecPelayananPasien", model.getNoRec());
				}
			}

		}
		return result;
	}

	@Override
	public List<Map<String, Object>> riwayatRegistrasiPasien(String noCm, String noRegistrasi, String start,
			String end) {
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		result = antrianPasienDiPeriksaDaoCustom.findAllAntrianByNocmAndNoreg(noCm, noRegistrasi, start, end);
		return result;
	}

	@Override
	public Map<String, Object> riwayatAntrianPasien(String noRec) {
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("antrian", antrianPasienDiPeriksaDaoCustom.findAllAntrianByNoreg(noRec));
		result.put("ICD10", diagnosaPasienDao.getDiagnosaPasienByNoRecPasienDaftar(noRec));
		result.put("ICD9", diagnosaPasienTindakanDao.getDiagnosaPasienByNoRecPasienDaftar(noRec));
		return result;
	}

	@Override
	public Map<String, Object> updateKelas(RegistrasiPelayananVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<StrukPelayanan> strukPelayanan = strukPelayananDao.getStrukPelayanan(vo.getNoRecPasienDaftar());
		/*
		 * if (CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
		 * result.put("statusPasien", "Pasien tidak dapat update kelas"); return
		 * result; } else {
		 */
		String KdDepartemenInstalasiGawatDarurat = pelayananPasienDao
				.getSettingDataFixed("KdDepartemenInstalasiGawatDarurat");

		String KdDepartemenInstalasiRawatInap = pelayananPasienDao
				.getSettingDataFixed("KdDepartemenInstalasiRawatInap");

		String KdInstalasiICU = pelayananPasienDao.getSettingDataFixed("KdInstalasiICU");

		AntrianPasienDiPeriksa antrianPasienDiPeriksa = null;

		Integer instalasiGawatDarurat = Integer.parseInt(KdDepartemenInstalasiGawatDarurat);
		Integer instalasiRawatInap = Integer.parseInt(KdDepartemenInstalasiRawatInap);
		Integer instalasiICU = Integer.parseInt(KdInstalasiICU);

		if (CommonUtil.isNotNullOrEmpty(vo)) {
			PasienDaftar pasienDaftar = pasienDaftarDao.findByNoRec(vo.getNoRecPasienDaftar());
			pasienDaftar.setNoRec(vo.getNoRecPasienDaftar());

			Set<AntrianPasienDiPeriksa> antrianPasienDiPeriksaSet = new HashSet<>();
			String noRec = "";
			AntrianPasienDiPeriksa antrianNew = new AntrianPasienDiPeriksa();
			if (CommonUtil.isNotNullOrEmpty(vo.getNoRecAntrianPasien())) {
				antrianPasienDiPeriksa = antrianPasienDiPeriksaDao.findByNoRec(vo.getNoRecAntrianPasien());
				if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
					antrianNew.setAsalRujukan(antrianPasienDiPeriksa.getAsalRujukan());
					antrianNew.setKasusPenyakit(antrianPasienDiPeriksa.getKasusPenyakit());
					antrianNew.setNoAntrian(antrianPasienDiPeriksa.getNoAntrian());
					antrianNew.setNoMasuk(antrianPasienDiPeriksa.getNoMasuk());
					antrianNew.setPasienDaftar(antrianPasienDiPeriksa.getPasienDaftar());
					antrianNew.setTglRegistrasi(antrianPasienDiPeriksa.getTglRegistrasi());
					antrianNew.setTglMasuk(new Date());
					antrianNew.setStrukRetur(antrianPasienDiPeriksa.getStrukRetur());
					antrianNew.setStatusPenyakit(antrianPasienDiPeriksa.getStatusPenyakit());
					antrianNew.setStatusKunjungan(antrianPasienDiPeriksa.getStatusKunjungan());
					antrianNew.setStatusPasien(antrianPasienDiPeriksa.getStatusPasien());
					antrianNew.setStatusAntrian(antrianPasienDiPeriksa.getStatusAntrian());
					antrianNew.setStatusEnabled(true);
					antrianNew.setRuanganAsal(antrianPasienDiPeriksa.getRuanganAsal());
					antrianNew.setPegawai(antrianPasienDiPeriksa.getPegawai());
					antrianPasienDiPeriksa.setTglKeluar(new Date());
				}
			}

			if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
				pasienDaftar.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
				antrianNew.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));

				Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());

				if (ruangan.getDepartemenId() == instalasiRawatInap || ruangan.getDepartemenId() == instalasiICU) {
					if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
						antrianNew.setKelas(kelasConverter.transferVOToModel(vo.getKelas(), new Kelas()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKamar())) {
						antrianNew.setKamar(kamarConverter.transferVOToModel(vo.getKamar(), new Kamar()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
						antrianNew.setNoBed(vo.getNomorTempatTidur().getId());
					}
					if (CommonUtil.isNotNullOrEmpty(StatusAntrianEnum.MASUK_KAMAR.getVal())) {
						antrianNew.setStatusAntrian(StatusAntrianEnum.MASUK_KAMAR.getVal());
					}
				}
			}
			if (CommonUtil.isNotNullOrEmpty(antrianNew)) {
				antrianPasienDiPeriksaSet.add(antrianNew);
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksa)) {
				antrianPasienDiPeriksaSet.add(antrianPasienDiPeriksa);
			}
			if (CommonUtil.isNotNullOrEmpty(antrianPasienDiPeriksaSet)) {
				pasienDaftar.setAntrianPasienDiPeriksaSet(antrianPasienDiPeriksaSet);
			}
			/*
			 * ------------------SAVE PASIEN DAFTAR------------------
			 */

			PasienDaftar passienDaftarResult = pasienDaftarDao.save(pasienDaftar);
			List<RegistrasiPelayananPasien> registrasiPelayananPasiens = registrasiPelayananPasienDao
					.finByNoRecPasiendaftar(pasienDaftar.getNoRec());
			RegistrasiPelayananPasien registrasiPelayananPasien = new RegistrasiPelayananPasien();
			if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasiens)) {
				registrasiPelayananPasien = registrasiPelayananPasiens.get(0);
			}
			if (CommonUtil.isNotNullOrEmpty(passienDaftarResult)) {
				result.put("noRec", pasienDaftar.getNoRec());
				result.put("noRecAntrian", antrianNew.getNoRec());
				result.put("noRegistrasi", pasienDaftar.getNoRegistrasi());
				result.put("noAntrian", antrianNew.getNoAntrian());
				if (CommonUtil.isNotNullOrEmpty(pasienDaftar.getPasien())) {
					result.put("noCm", pasienDaftar.getPasien().getNoCm());
				}
				if (passienDaftarResult.getRuangan().getDepartemenId() == instalasiRawatInap) {
					Kamar kamar = kamarDao.findOne(vo.getKamar().getId());

					if (CommonUtil.isNotNullOrEmpty(kamar)) {
						Integer jumlahKamarIsi = kamar.getJumlaKamarIsi() + 1;
						if (CommonUtil.isNotNullOrEmpty(jumlahKamarIsi)) {
							kamar.setJumlaKamarIsi(jumlahKamarIsi);
						}
						Integer jumlahKamarKosong = kamar.getJumlaKamarKosong() - 1;
						if (CommonUtil.isNotNullOrEmpty(jumlahKamarKosong)) {
							kamar.setJumlaKamarKosong(jumlahKamarKosong);
						}
						if (CommonUtil.isNotNullOrEmpty(kamar) && vo.getRawatGabung().FALSE) {
							Kamar resultKamar = kamarDao.save(kamar);
							if (CommonUtil.isNotNullOrEmpty(resultKamar)
									&& CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
								tambahKamarKosong(registrasiPelayananPasien.getKamarId(), result);
							}
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
						TempatTidur tempatTidur = tempatTidurDao.findOne(vo.getNomorTempatTidur().getId());
						StatusBed statusBed = new StatusBed();
						statusBed.setId(1);

						if (CommonUtil.isNotNullOrEmpty(tempatTidur) && vo.getRawatGabung().FALSE) {
							tempatTidur.setStatusBed(statusBed);
							TempatTidur resultTempatTidur = tempatTidurDao.save(tempatTidur);
							if (CommonUtil.isNotNullOrEmpty(resultTempatTidur)
									&& CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
								tambahBedKosong(registrasiPelayananPasien.getTempatTidur().getId(), result);
							}
						}
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKamar())) {
						registrasiPelayananPasien
								.setKamar(kamarConverter.transferVOToModel(vo.getKamar(), new Kamar()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getKelas())) {
						registrasiPelayananPasien
								.setKelas(kelasConverter.transferVOToModel(vo.getKelas(), new Kelas()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						registrasiPelayananPasien
								.setRuangan(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
					}
					if (CommonUtil.isNotNullOrEmpty(vo.getNomorTempatTidur())) {
						TempatTidur tempatTidur = tempatTidurDao.findOne(vo.getNomorTempatTidur().getId());
						registrasiPelayananPasien.setTempatTidur(tempatTidur);
					}
					if (CommonUtil.isNotNullOrEmpty(registrasiPelayananPasien)) {
						registrasiPelayananPasienDao.save(registrasiPelayananPasien);
					}
					// added akomodasi to pelayanan pasien and pelayanan
					// pasien detail -->added by susy
					/*Map<String, Object> pelayananPasien = saveAkomodasi(antrianPasienDiPeriksa, vo.getRawatGabung(),
							false, true);
					if (CommonUtil.isNotNullOrEmpty(pelayananPasien)) {
						result.putAll(pelayananPasien);
					}*/
				}
			}
		}

		return result;
		// }
	}

	@Override
	public Map<String, Object> trigerringSaveAkomodasi(String noRecPasienDaftar) {
		Map<String, Object> result = new HashMap<String, Object>();
		// trigering saveAkomodasi function *add by susy 20171108
		String akomodasi = pelayananPasienDao.getSettingDataFixed("akomodasi");
		String jenisProdukAkomodasi = pelayananPasienDao.getSettingDataFixed("jenisProdukAkomodasi");

		/*
		 * List<AntrianPasienDiPeriksa> listAntrian =
		 * antrianPasienDiPeriksaDaoCustom
		 * .findDataRawatInapforAkomodasi(Integer.valueOf(jenisProdukAkomodasi))
		 * ; /*for (AntrianPasienDiPeriksa antrian : listAntrian) {
		 * saveAkomodasi(antrian,antrian.getIsRawatGabung(), true, false); }
		 */
		List<AntrianPasienDiPeriksa> listAntrian = antrianPasienDiPeriksaDaoCustom
				.findAntrianforAkomodasi(noRecPasienDaftar);
		if (CommonUtil.isNotNullOrEmpty(listAntrian)) {
			AntrianPasienDiPeriksa antrian = listAntrian.get(0);
			result = saveAkomodasi(antrian, antrian.getIsRawatGabung(), true, false);
		}
		// end
		return result;
	}
}
