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.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.persistence.Query;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import com.jasamedika.medifirst2000.converter.BaseConverterImpl;
import com.jasamedika.medifirst2000.dao.AntrianPasienDiPeriksaDao;
import com.jasamedika.medifirst2000.dao.AsalRujukanDao;
import com.jasamedika.medifirst2000.dao.DetailRadiologiDao;
import com.jasamedika.medifirst2000.dao.DiagnosaPasienDao;
import com.jasamedika.medifirst2000.dao.HargaNettoProdukByKelasDDao;
import com.jasamedika.medifirst2000.dao.HasilPemeriksaanDao;
import com.jasamedika.medifirst2000.dao.HasilPemeriksaanDuploDao;
import com.jasamedika.medifirst2000.dao.JenisWaktuDao;
import com.jasamedika.medifirst2000.dao.KelasDao;
import com.jasamedika.medifirst2000.dao.LogAccDao;
import com.jasamedika.medifirst2000.dao.MapProdukMenuToBahanDao;
import com.jasamedika.medifirst2000.dao.MapRuanganToProdukDao;
//import com.jasamedika.medifirst2000.dao.HasilPemeriksaanImageDao;
import com.jasamedika.medifirst2000.dao.OrderPelayananDao;
import com.jasamedika.medifirst2000.dao.OrderProdukDao;
import com.jasamedika.medifirst2000.dao.PapAlergiDao;
import com.jasamedika.medifirst2000.dao.PasienDaftarDao;
import com.jasamedika.medifirst2000.dao.PasienDao;
import com.jasamedika.medifirst2000.dao.PelayananPasienDao;
import com.jasamedika.medifirst2000.dao.ProdukDao;
import com.jasamedika.medifirst2000.dao.ProdukDetailLaboratoriumDao;
import com.jasamedika.medifirst2000.dao.ProdukProduksiDao;
import com.jasamedika.medifirst2000.dao.RuanganDao;
import com.jasamedika.medifirst2000.dao.RunningNumberDao;
import com.jasamedika.medifirst2000.dao.SiklusGiziDao;
import com.jasamedika.medifirst2000.dao.StokProdukGlobalDao;
import com.jasamedika.medifirst2000.dao.StrukHasilPemeriksaanDao;
import com.jasamedika.medifirst2000.dao.StrukHistoriDao;
import com.jasamedika.medifirst2000.dao.StrukKirimDao;
import com.jasamedika.medifirst2000.dao.StrukOrderDao;
import com.jasamedika.medifirst2000.dao.custom.OrderProdukDaoCustom;
import com.jasamedika.medifirst2000.dto.CekStokProdukRuanganDto;
import com.jasamedika.medifirst2000.dto.OrderPelayananGiziDto;
import com.jasamedika.medifirst2000.dto.PiutangRekananProfileTemp;
//import com.jasamedika.medifirst2000.vo.UploadVO;
import com.jasamedika.medifirst2000.entities.AntrianPasienDiPeriksa;
import com.jasamedika.medifirst2000.entities.BentukProduk;
import com.jasamedika.medifirst2000.entities.DetailOrderTindakan;
import com.jasamedika.medifirst2000.entities.DetailRadiologi;
import com.jasamedika.medifirst2000.entities.DiagnosaPasien;
import com.jasamedika.medifirst2000.entities.HargaNettoProdukByKelasD;
import com.jasamedika.medifirst2000.entities.HasilPemeriksaan;
import com.jasamedika.medifirst2000.entities.HasilPemeriksaanDuplo;
//import com.jasamedika.medifirst2000.entities.HasilPemeriksaanImage;
import com.jasamedika.medifirst2000.entities.JenisDiet;
import com.jasamedika.medifirst2000.entities.JenisPetugasPelaksana;
import com.jasamedika.medifirst2000.entities.JenisWaktu;
import com.jasamedika.medifirst2000.entities.Kelas;
import com.jasamedika.medifirst2000.entities.LisOrder;
import com.jasamedika.medifirst2000.entities.LogAcc;
import com.jasamedika.medifirst2000.entities.MapProdukMenuToBahan;
import com.jasamedika.medifirst2000.entities.MapRuanganToProduk;
import com.jasamedika.medifirst2000.entities.OrderPelayanan;
import com.jasamedika.medifirst2000.entities.OrderProduk;
import com.jasamedika.medifirst2000.entities.PapAlergi;
import com.jasamedika.medifirst2000.entities.PapPengambilanSpesimen;
import com.jasamedika.medifirst2000.entities.Pasien;
import com.jasamedika.medifirst2000.entities.PasienDaftar;
import com.jasamedika.medifirst2000.entities.PelayananPasien;
import com.jasamedika.medifirst2000.entities.PelayananPasienDetail;
import com.jasamedika.medifirst2000.entities.PelayananPasienPetugas;
import com.jasamedika.medifirst2000.entities.Produk;
import com.jasamedika.medifirst2000.entities.ProdukDetailLaboratorium;
import com.jasamedika.medifirst2000.entities.ProdukProduksi;
import com.jasamedika.medifirst2000.entities.RencanaOperasi;
import com.jasamedika.medifirst2000.entities.Ruangan;
import com.jasamedika.medifirst2000.entities.RunningNumber;
import com.jasamedika.medifirst2000.entities.SiklusGizi;
import com.jasamedika.medifirst2000.entities.StrukHasilPemeriksaan;
import com.jasamedika.medifirst2000.entities.StrukHistori;
import com.jasamedika.medifirst2000.entities.StrukKirim;
import com.jasamedika.medifirst2000.entities.StrukOrder;
import com.jasamedika.medifirst2000.entities.TipeMakanan;
import com.jasamedika.medifirst2000.enums.StatusAntrianEnum;
import com.jasamedika.medifirst2000.enums.StatusGiziEnum;
import com.jasamedika.medifirst2000.service.AntrianPasienDiPeriksaService;
import com.jasamedika.medifirst2000.service.HasilPemeriksaanService;
import com.jasamedika.medifirst2000.service.KartuStokService;
import com.jasamedika.medifirst2000.service.LoginUserService;
import com.jasamedika.medifirst2000.service.OrderProdukService;
import com.jasamedika.medifirst2000.service.PelayananPiutangRekananService;
import com.jasamedika.medifirst2000.service.PphpService;
import com.jasamedika.medifirst2000.service.ProdukService;
import com.jasamedika.medifirst2000.service.RegistrasiPasienService;
import com.jasamedika.medifirst2000.service.RegistrasiPelayananService;
import com.jasamedika.medifirst2000.service.StokProdukGlobalService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.DateUtil;
import com.jasamedika.medifirst2000.util.JsonUtil;
import com.jasamedika.medifirst2000.util.StringUtil;
import com.jasamedika.medifirst2000.vo.AsalRujukanVO;
import com.jasamedika.medifirst2000.vo.BentukProdukVO;
import com.jasamedika.medifirst2000.vo.DetailHasilDeviceVO;
import com.jasamedika.medifirst2000.vo.DetailOrderTindakanVO;
import com.jasamedika.medifirst2000.vo.DetailRadiologiVO;
import com.jasamedika.medifirst2000.vo.HasilPemeriksaanVO;
import com.jasamedika.medifirst2000.vo.HeaderDetailHasilDeviceVO;
import com.jasamedika.medifirst2000.vo.JenisKelaminVO;
import com.jasamedika.medifirst2000.vo.JenisWaktuVO;
import com.jasamedika.medifirst2000.vo.KasusPenyakitVO;
import com.jasamedika.medifirst2000.vo.KategoryProdukVO;
import com.jasamedika.medifirst2000.vo.KelompokPasienVO;
import com.jasamedika.medifirst2000.vo.KirimProdukVO;
import com.jasamedika.medifirst2000.vo.OrderPelayananVO;
import com.jasamedika.medifirst2000.vo.OrderProdukGiziVO;
import com.jasamedika.medifirst2000.vo.OrderProdukVO;
import com.jasamedika.medifirst2000.vo.PasienVO;
import com.jasamedika.medifirst2000.vo.PendidikanVO;
import com.jasamedika.medifirst2000.vo.ProdukDetailLaboratoriumVO;
import com.jasamedika.medifirst2000.vo.ProdukVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPasienVO;
import com.jasamedika.medifirst2000.vo.RegistrasiPelayananVO;
import com.jasamedika.medifirst2000.vo.RencanaOperasiVO;
import com.jasamedika.medifirst2000.vo.RuanganVO;
import com.jasamedika.medifirst2000.vo.SiklusGiziVO;
import com.jasamedika.medifirst2000.vo.StatusPerkawinanVO;
import com.jasamedika.medifirst2000.vo.StrukKirimVO;
import com.jasamedika.medifirst2000.vo.StrukOrderVO;

/**
 * Implement class for OrderProdukService
 * 
 * @author Generator
 * @param <T>
 */
@Service("orderProdukService")
public class OrderProdukServiceImpl extends BaseVoServiceImpl implements OrderProdukService {
	private static final Logger LOGGER = LoggerFactory.getLogger(OrderProdukServiceImpl.class);
	@Autowired
	private ProdukService produkService;	
	@Autowired
	private KelasDao kelasDao;
	@Autowired
	private BaseConverterImpl<RencanaOperasiVO, RencanaOperasi> rencanaOperasiConverter;
	@Autowired
	private BaseConverterImpl<OrderProdukVO, OrderProduk> orderProdukConverter;
	@Autowired
	private BaseConverterImpl<DetailOrderTindakanVO, DetailOrderTindakan> orderTindakanLabConverter;

	@Autowired
	private BaseConverterImpl<ProdukVO, Produk> produkConverter;

	@Autowired
	private BaseConverterImpl<StrukOrderVO, StrukOrder> strukOrderConverter;
	@Autowired
	private BaseConverterImpl<DetailRadiologiVO, DetailRadiologi> detailRadiologiConverter;

	@Autowired
	private BaseConverterImpl<OrderPelayananVO, OrderPelayanan> orderPelayananConverter;
	@Autowired
	private OrderProdukDao orderProdukDao;

	@Autowired
	private PasienDaftarDao pasienDaftarDao;
	@Autowired
	private StrukOrderDao strukOrderDao;
	@Autowired
	private RuanganDao ruanganDao;
	@Autowired
	private AntrianPasienDiPeriksaDao antrianPasienDiPeriksaDao;
	@Autowired
	private AsalRujukanDao asalRujukanDao;
	@Autowired
	private OrderPelayananDao orderPelayananDao;
	@Autowired
	private RunningNumberDao runningNumberDao;
	@Autowired
	private AntrianPasienDiPeriksaService antrianPasienDiPeriksaService;
	@Autowired
	private LoginUserService loginUserService;
	@Autowired
	private DetailRadiologiDao detailRadiologiDao;
	@Autowired
	private ProdukDao produkDao;
	@Autowired
	private MapRuanganToProdukDao mapRuanganToProdukDao;
	@Autowired
	private PelayananPiutangRekananService pelayananPiutangRekananService;
	@Autowired
	private PelayananPasienDao pelayananPasienDao;
	@Autowired
	private SiklusGiziDao siklusGiziDao;
	@Autowired
	private StrukHistoriDao strukHistoriDao;
	@Autowired
	private ProdukProduksiDao produkProduksiDao;

	@Autowired
	private StokProdukGlobalDao stokProdukGlobalDao;
	
	@Autowired
	private DiagnosaPasienDao diagnosaPasienDao;
	
	@Autowired
	private PapAlergiDao papAlergiDao;
	
	@Autowired
	private KartuStokService kartuStokService;
	
	@Autowired
	private StokProdukGlobalService stokProdukGlobalService;
	
	@Autowired
	private LogAccDao logAccDao;
	
	// sebelum di rombak khusus untuk laborat
	private int cito = 0;

	@Autowired
	private PphpService pphpService;
	
	
	@Autowired
	private MapProdukMenuToBahanDao mapProdukMenuToBahanDao;
	
	@Autowired
	private JenisWaktuDao jenisWaktuDao;
	
	@Autowired
	private OrderProdukDaoCustom orderProdukDaoCustom;

	@Override
	@Transactional(readOnly = false, isolation = Isolation.SERIALIZABLE)
	public Map<String, Object> saveOrderProduk(OrderProdukVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		OrderProduk model = new OrderProduk();

		model = orderProdukConverter.transferVOToModel(vo, model);
		AntrianPasienDiPeriksa antrianPasienDiPeriksaBefore = null;
		if (vo.getNoRec() == null)
			antrianPasienDiPeriksaBefore = antrianPasienDiPeriksaDao.finByNoIdAndTglRegistrasi(Short.parseShort("0"),
					vo.getPasien().getId(), vo.getTglRegistrasi());
		else
			antrianPasienDiPeriksaBefore = antrianPasienDiPeriksaDao.findByNoRec(vo.getNoRec());
		// calender.get(Calendar.YEAR),calender.get(Calendar.MONTH)+1,vo.getTglRegistrasi().getDate(),vo.getTglRegistrasi().getHours(),vo.getTglRegistrasi().getMinutes(),vo.getTglRegistrasi().getSeconds()
		// );
		// pasienDaftar=pasienDaftarDao.finByNoIdAndTglRegistrasi(Short.parseShort("0"),
		// vo.getPasien().getId(),format+",000",format+",999");
		model.setPasien(antrianPasienDiPeriksaBefore);

		Map<String, Ruangan> listRuangan = new HashMap<>();

		String noOrderIntern = null;
		Ruangan ruanganTujuan = new Ruangan();
		if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {

			Ruangan ruangan = ruanganDao.findOne(vo.getRuangan().getId());
			ruanganTujuan.setId(vo.getRuangan().getId());
			listRuangan.put(ruanganTujuan.getNamaRuangan(), ruanganTujuan);
			for (DetailOrderTindakanVO subModel : vo.getOrderTindakan()) {
				RuanganVO ruanganVo = new RuanganVO();
				ruanganVo.setId(ruanganTujuan.getId());
				subModel.setRuangan(ruanganVo);
			}
			if (ruangan.getKdInternal() != null)
				noOrderIntern = ruangan.getKdInternal() + getRunningNumber(ruangan.getNamaRuangan());
		} else {
			if (CommonUtil.isNotNullOrEmpty(vo.getDetailRadiologi())) {
				ruanganTujuan = (ruanganDao
						.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdRuanganRadiologi"))));
				noOrderIntern = "R" + getRunningNumber("Radiologi");
				listRuangan.put(ruanganTujuan.getNamaRuangan(), ruanganTujuan);
				for (DetailOrderTindakanVO subModel : vo.getOrderTindakan()) {
					RuanganVO ruanganVo = new RuanganVO();
					ruanganVo.setId(ruanganTujuan.getId());
					subModel.setRuangan(ruanganVo);
				}
			} else {
				for (DetailOrderTindakanVO subModel : vo.getOrderTindakan()) {
					for (MapRuanganToProduk mapRuanganToProduk : mapRuanganToProdukDao
							.findByProdukId(subModel.getProduk().getId())) {
						Ruangan ruangan = listRuangan.get(mapRuanganToProduk.getRuangan().getNamaRuangan());
						if (ruangan == null) {
							RuanganVO ruanganVo = new RuanganVO();
							ruanganVo.setId(mapRuanganToProduk.getRuangan().getId());
							subModel.setRuangan(ruanganVo);
							listRuangan.put(mapRuanganToProduk.getRuangan().getNamaRuangan(),
									mapRuanganToProduk.getRuangan());
						} else {
							RuanganVO ruanganVo = new RuanganVO();
							ruanganVo.setId(mapRuanganToProduk.getRuangan().getId());
							subModel.setRuangan(ruanganVo);
						}
					}
				}
				ruanganTujuan = (ruanganDao
						.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdRuanganLaboratorium"))));
				if (listRuangan.size() == 0) {
					for (DetailOrderTindakanVO subModel : vo.getOrderTindakan()) {
						RuanganVO ruanganVo = new RuanganVO();
						ruanganVo.setId(ruanganTujuan.getId());
						subModel.setRuangan(ruanganVo);
					}
					listRuangan.put(ruanganTujuan.getNamaRuangan(), ruanganTujuan);
				}
				noOrderIntern = "L" + getRunningNumber("Laboratorium");
			}
		}
		AntrianPasienDiPeriksa antrianPasienDiPeriksa = null;
		StrukOrder strukOrder = null;
		OrderProduk resultDomain = null;
		for (Map.Entry<String, Ruangan> entry : listRuangan.entrySet()) {
			String key = entry.getKey();
			Ruangan value = entry.getValue();

			// if(listRuangan.size()==0)
			{

				antrianPasienDiPeriksa = new AntrianPasienDiPeriksa();
				antrianPasienDiPeriksa.setRuangan(value);
				strukOrder = new StrukOrder();

				if (CommonUtil.isNotNullOrEmpty(vo.getStrukOrder())) {
					strukOrderConverter.setUseGson(true);
					strukOrder = strukOrderConverter.transferVOToModel(vo.getStrukOrder(), strukOrder);
					// add by askur 15122016
					// strukOrder.setNoOrder(StringUtil
					// .formatNumber(String.valueOf(strukOrderDao.getCountByMonthAndYear(new
					// Date()) + 1), 10));
					strukOrder.setNoOrder(getRunningNumber("NoOrder"));
					//
					strukOrder.setTglOrder(vo.getStrukOrder().getTglOrder());
					//System.out.println(new SimpleDateFormat("dd-MM-yyyy").format(vo.getStrukOrder().getTglOrder()) + "test ya");
					strukOrder.setIsDelivered((byte) 1);
					strukOrder.setQtyJenisProduk(1.0);
					strukOrder.setNoCm(model.getPasien().getPasienDaftar().getPasien());
					strukOrder.setNoRegistrasi(model.getPasien().getPasienDaftar());
					strukOrder.setQtyProduk(1.0);
					strukOrder.setTotalBeaMaterai(0.0);
					strukOrder.setTotalBiayaKirim(0.0);
					strukOrder.setTotalBiayaTambahan(0.0);
					strukOrder.setTotalHargaSatuan(0.0);
					strukOrder.setTotalDiscount(0.0);
					strukOrder.setTotalHarusDibayar(0.0);
					strukOrder.setTotalPph(0.0);
					strukOrder.setTotalPpn(0.0);
					if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
						ruanganTujuan = new Ruangan();
						ruanganTujuan.setId(vo.getRuangan().getId());
						strukOrder.setRuanganTujuan(ruanganTujuan);
					} else {
						strukOrder.setRuanganTujuan(antrianPasienDiPeriksa.getRuangan());
					}

					strukOrder.setRuangan(model.getPasien().getRuangan());
					strukOrder.setKeteranganOrder(vo.getKeteranganOrder());
					strukOrder.setNoOrderIntern(noOrderIntern);
				

					strukOrder.setPegawaiOrder(loginUserService.getLoginUser().getPegawai());

					model.setStrukOrder(strukOrder);

					antrianPasienDiPeriksa.setAsalRujukan(asalRujukanDao
							.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdAsalRujukanPoliklinik"))));

					antrianPasienDiPeriksa.setTglRegistrasi(strukOrder.getTglOrder());

					antrianPasienDiPeriksa.setStatusPasien((byte) 1);
					antrianPasienDiPeriksa.setPasienDaftar(model.getPasien().getPasienDaftar());
					antrianPasienDiPeriksa.setNoAntrian(antrianPasienDiPeriksaService.getFormatNumberByMonthYearRuangan(
							vo.getStrukOrder().getTglOrder(), antrianPasienDiPeriksa.getRuangan().getId()));
					antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MENUNGGU.getVal());
					Kelas nonKelas = kelasDao.findNonKelas();
					if(CommonUtil.isNotNullOrEmpty(nonKelas))
					{
						antrianPasienDiPeriksa.setKelas(nonKelas);											
					}
					antrianPasienDiPeriksa.setStrukOrder(strukOrder);
					antrianPasienDiPeriksa = (AntrianPasienDiPeriksa) antrianPasienDiPeriksaDao
							.save(antrianPasienDiPeriksa);
	
					//-----------------------------------------------------
					Set<RencanaOperasi> rencanaOperasiSet = new HashSet<>();
					if(CommonUtil.isNotNullOrEmpty(vo.getStrukOrder().getRencanaOperasi())){
						
						RencanaOperasi rencanaOperasi = rencanaOperasiConverter.transferVOToModel(vo.getStrukOrder().getRencanaOperasi(), new RencanaOperasi());	
						if (CommonUtil.isNotNullOrEmpty(strukOrder)) {
							rencanaOperasi.setStrukOrder(strukOrder);
							rencanaOperasi.setNoCm(antrianPasienDiPeriksa);
						}
						if(CommonUtil.isNotNullOrEmpty(rencanaOperasi)) {
							rencanaOperasiSet.add(rencanaOperasi);
						}
					}
					if(CommonUtil.isNotNullOrEmpty(rencanaOperasiSet)) {
						strukOrder.setRencanaOperasi(rencanaOperasiSet);
					}
					
					strukOrderDao.save(strukOrder);
				}
				for (DetailOrderTindakanVO subModel : vo.getOrderTindakan()) {
					if (CommonUtil.isNotNullOrEmpty(subModel)
							&& subModel.getRuangan().getId() == antrianPasienDiPeriksa.getRuangan().getId()) {
						orderTindakanLabConverter.setUseGson(true);
						DetailOrderTindakan newsubModel = orderTindakanLabConverter.transferVOToModel(subModel,
								new DetailOrderTindakan());
						newsubModel.setPasien(model.getPasien());
						newsubModel.setOrderProduk(model);
						OrderPelayanan orderPelayanan = new OrderPelayanan();
						orderPelayanan.setStrukOrder(strukOrder);
						JenisDiet jenisDiet = new JenisDiet();
						if (subModel.getJenisDiet() != null) {
							jenisDiet.setId(subModel.getJenisDiet().getId());
							orderPelayanan.setJenisDiet(jenisDiet);
						}

						JenisWaktu jenisWaktu = new JenisWaktu();
						if (subModel.getJenisWaktu() != null) {
							jenisWaktu.setId(subModel.getJenisWaktu().getId());
							orderPelayanan.setJenisWaktu(jenisWaktu);
						}
						// edit by askur 02122016
						// add by askur 021120161018
						// if(subModel.getTipeMakanan()!=null){
						//
						// orderPelayanan.setTipeMakanan(BaseConverterImpl.transferVOToModelData(subModel.getTipeMakanan(),
						// new TipeMakanan()));
						// }
						//
						// add by askur 02122016
						if (subModel.getTipeMakanan() != null) {
							BentukProdukVO bentukProduk = new BentukProdukVO();
							bentukProduk.setId(subModel.getTipeMakanan().getId());
							orderPelayanan.setBentukProduk(
									BaseConverterImpl.transferVOToModelData(bentukProduk, new BentukProduk()));
						}
						//
						orderPelayanan.setRuanganTujuan(antrianPasienDiPeriksa.getRuangan());
						orderPelayanan.setRuangan(model.getPasien().getRuangan());
						orderPelayanan.setProduk(newsubModel.getProduk());
						orderPelayanan.setNoOrder(strukOrder);
						orderPelayanan.setIsCito((byte)cito);
						// add by askur 04102016
						if (subModel.getQtyProduk() == null)
							subModel.setQtyProduk(1.0);
						//
						orderPelayanan.setQtyProduk(subModel.getQtyProduk());
						orderPelayanan.setQtyProdukRetur(1.0);
						if (subModel.getProduk().getGolonganDarah() != null) {
							Produk resultProduk = produkService.findByBentukProdukIdAndRhesusIdAndGolonganDarahId(
									subModel.getProduk().getBentukProduk().getId(),
									subModel.getProduk().getRhesus().getId(),
									subModel.getProduk().getGolonganDarah().getId());
							subModel.setProduk(produkConverter.transferModelToVO(resultProduk, new ProdukVO()));
						}

						orderPelayanan.setProduk(produkConverter.transferVOToModel(subModel.getProduk(), new Produk()));
						orderPelayanan.setTglPelayanan(strukOrder.getTglOrder());
						orderPelayananDao.save(orderPelayanan);
						// model.getOrderTindakan().add(newsubModel);
					}
				}
				model.getOrderTindakan().clear();

				resultDomain = orderProdukDao.save(model);
				if (CommonUtil.isNotNullOrEmpty(vo.getDetailRadiologi())) {
					DetailRadiologi detailRadiologi = new DetailRadiologi();
					detailRadiologi = detailRadiologiConverter.transferVOToModel(vo.getDetailRadiologi(),
							new DetailRadiologi());
					detailRadiologi.setOrderProduk(resultDomain);
					detailRadiologi.setPasien(model.getPasien());
					detailRadiologiDao.save(detailRadiologi);
				}
			}

			if (CommonUtil.isNotNullOrEmpty(resultDomain)) {
				result.put("noRec", resultDomain.getNoRec());
				result.put("noOrder", strukOrder.getNoOrder());
				result.put("noOrderIntern", strukOrder.getNoOrderIntern());
			}

		}

		return result;
	}

	private String getRunningNumber(String kegunaan) {
		RunningNumber runningNumber = runningNumberDao.findByResetAndKegunaan("0", kegunaan);
		if (runningNumber == null) {
			runningNumber = new RunningNumber();
			runningNumber.setKegunaan(kegunaan);
			runningNumber.setReset("0");
			runningNumber.setNomerTerbaru((Integer) 0);
		}
		Integer number = (runningNumber.getNomerTerbaru() + (Integer) 1);
		runningNumber.setNomerTerbaru(runningNumber.getNomerTerbaru() + (Integer) 1);
		String noOrderIntern = StringUtil.formatNumber(number.toString(), 10);
		runningNumberDao.save(runningNumber);
		return noOrderIntern;
	}

	@Autowired
	private BaseConverterImpl<ProdukDetailLaboratoriumVO, ProdukDetailLaboratorium> produkDetailLaboratoriumConverter;
	
	@Autowired
	private BaseConverterImpl<HasilPemeriksaanVO, HasilPemeriksaan> hasilPemeriksaanConverter;

	@Autowired
	private HasilPemeriksaanService hasilPemeriksaanService;
	
	@Autowired
	private HargaNettoProdukByKelasDDao hargaNettoProdukByKelasDDao;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveHasilPelayanan(String noOrder, List<HasilPemeriksaanVO> vo) {
		Map<String, Object> result = new HashMap<String, Object>();		
		StrukHasilPemeriksaan strukHasilPemeriksaan = new StrukHasilPemeriksaan();
		//--------------------------------------------------------------------------------------
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		if(CommonUtil.isNotNullOrEmpty(strukOrder)) {
			strukHasilPemeriksaan.setStrukOrder(strukOrder);
			strukHasilPemeriksaan.setTglHasil(new Date());
		}
		//--------------------------------------------------------------------------------------
		if(vo.size() > 0) {
			strukHasilPemeriksaan.setKeteranganLainnya(vo.get(0).getKeterangan());
			if (vo.get(0).getStrukHasilPemeriksaan() != null) {
				strukHasilPemeriksaan.setNoRec(vo.get(0).getStrukHasilPemeriksaan().getNoRec());
			}
		} else {
			strukHasilPemeriksaan.setKeteranganLainnya("");
		}
		//--------------------------------------------------------------------------------------
		String noHasilPemeriksaan = hasilPemeriksaanService.generateNoHasilPeriksa(new Date());
		if(CommonUtil.isNotNullOrEmpty(noHasilPemeriksaan)) {
			strukHasilPemeriksaan.setNoHasilPeriksa(noHasilPemeriksaan);
		}
		//--------------------------------------------------------------------------------------
		List<OrderPelayanan> listOrderPelayanan = orderPelayananDao.findOrderByNoOrder(noOrder);
		for(OrderPelayanan orderPelayanan : listOrderPelayanan) {
			orderPelayanan.setNoHasilPeriksa(strukHasilPemeriksaan);
			hasilPemeriksaanService.save(orderPelayanan);
		}
		//--------------------------------------------------------------------------------------
		if(vo.get(0).getNoRec() != null) {
			HasilPemeriksaan model = new HasilPemeriksaan();
			model.setNoRec(vo.get(0).getNoRec());
			
			if (hasilPemeriksaanService.getStruk(model) != null) {
				strukHasilPemeriksaan.setNoRec(hasilPemeriksaanService.getStruk(model).getNoRec());
			}
		}
		//--------------------------------------------------------------------------------------
		if(CommonUtil.isNotNullOrEmpty(strukHasilPemeriksaan)) {
			hasilPemeriksaanService.save(strukHasilPemeriksaan);
		}
		//--------------------------------------------------------------------------------------
		for(HasilPemeriksaanVO subModel : vo) {
			HasilPemeriksaan hasilPemeriksaan = hasilPemeriksaanConverter.transferVOToModel(subModel, new HasilPemeriksaan());
			//--------------------------------------------------------------------------------------
			if(subModel.getDetail().getId() != null) {
				hasilPemeriksaan.setDetail(produkDetailLaboratoriumConverter.transferVOToModel(subModel.getDetail(),
						new ProdukDetailLaboratorium()));
			}
			//--------------------------------------------------------------------------------------
			if(subModel.getHasil() != null) {
				hasilPemeriksaan.setHasil(subModel.getHasil());
			}else {
				hasilPemeriksaan.setHasil("");
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(subModel.getExpertise())) {
				hasilPemeriksaan.setExpertise(subModel.getExpertise());
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(subModel.getKlinis())) {
				hasilPemeriksaan.setKlinis(subModel.getKlinis());
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(subModel.getComment())) {
				hasilPemeriksaan.setComment(subModel.getComment());
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(subModel.getDetail().getProduk())) {
				hasilPemeriksaan.setProduk(produkConverter.transferVOToModel(subModel.getDetail().getProduk(), new Produk()));
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(strukHasilPemeriksaan)) {
				hasilPemeriksaan.setStrukHasilPemeriksaan(strukHasilPemeriksaan);
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(subModel.getNoRec())) {
				hasilPemeriksaan.setNoRec(subModel.getNoRec());
			}
			//--------------------------------------------------------------------------------------
			if(CommonUtil.isNotNullOrEmpty(hasilPemeriksaan)) {
				hasilPemeriksaanService.save(hasilPemeriksaan);
			}
		}
		
		Byte statusVer = 0;
		for(HasilPemeriksaanVO hasil : vo) {
			statusVer = hasil.getStatusVerifikasi();
		}
		if(statusVer == 0) {
			for(OrderPelayanan orderPelayanan : listOrderPelayanan) {
				AntrianPasienDiPeriksa antrian = antrianPasienDiPeriksaDao.findByStrukOrderNoRec(strukOrder.getNoRec());
				//--------------------------------------------------------------------------------------
				Produk produk = produkDao.findOne(orderPelayanan.getProdukId());
				//--------------------------------------------------------------------------------------
				Map<String, Object> harga = getHarga(antrian, produk, orderPelayanan.getJumlah());
				//--------------------------------------------------------------------------------------
				PelayananPasien pelayanan = new PelayananPasien();
				if(CommonUtil.isNotNullOrEmpty(strukOrder)) {
					pelayanan.setStrukOrder(strukOrder);
					pelayanan.setStock(1.0);
					pelayanan.setJumlah(1.0);
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(orderPelayanan.getProduk())) {
					pelayanan.setProduk(orderPelayanan.getProduk());
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(orderPelayanan.getTglPelayanan())) {
					pelayanan.setTglPelayanan(orderPelayanan.getTglPelayanan());
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(antrian)) {
					pelayanan.setPasien(antrian);
					antrian.setStatusAntrian(StatusAntrianEnum.SELESAI_DIPERIKSA.getVal());
					antrianPasienDiPeriksaDao.save(antrian);
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(harga.get("hargaSatuan"))) {
					pelayanan.setHargaSatuan((Double)harga.get("hargaSatuan"));
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(harga.get("hargaJual"))) {
					pelayanan.setHargaJual((Double)harga.get("hargaJual"));
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(harga.get("hargaNetto"))) {
					pelayanan.setHargaNetto((Double)harga.get("hargaNetto"));
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(harga.get("hargaPiutangPenjamin"))) {
					pelayanan.setPiutangPenjamin((Double)harga.get("hargaPiutangPenjamin"));
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(harga.get("hargaPiutangRumahSakit"))) {
					pelayanan.setPiutangRumahSakit((Double)harga.get("hargaPiutangRumahSakit"));
				}
				//added by susy 21-02-2018
				if(CommonUtil.isNotNullOrEmpty(strukOrder.getPegawaiOrder()))
				{
					Set<PelayananPasienPetugas> pelayananPasienPetugasSet = new HashSet<>();
					PelayananPasienPetugas pelayananPasienPetugas = new PelayananPasienPetugas();
					pelayananPasienPetugas.setObjectPegawai(strukOrder.getPegawaiOrder());
					JenisPetugasPelaksana kdjenispetugaspe = new JenisPetugasPelaksana();
					kdjenispetugaspe.setId(4);
					pelayananPasienPetugas.setObjectJenisPetugasPe(kdjenispetugaspe);
					pelayananPasienPetugas.setPelayananPasien(pelayanan);
					pelayananPasienPetugas.setNoMasuk(antrian);
					pelayananPasienPetugasSet.add(pelayananPasienPetugas);
					pelayanan.getPelayananPasienPetugasSet().clear();
					pelayanan.setPelayananPasienPetugasSet(pelayananPasienPetugasSet);
				}
				if(CommonUtil.isNotNullOrEmpty(produk)) {
					Ruangan ruangan = ruanganDao.findOne(orderPelayanan.getRuangan().getId());//antrian.getKelas
					List<HargaNettoProdukByKelasD> detail = hargaNettoProdukByKelasDDao.findByKelasNProduk(antrian.getKelasId(), produk.getId());
					
					Set<PelayananPasienDetail> pelayananPasienDetailSet = new HashSet<>();
					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(orderPelayanan.getStrukOrder().getStatusOrder())){
							pelayananPasienDetail.setStatusOrder(orderPelayanan.getStrukOrder().getStatusOrder());
						}
						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());
							pelayananPasienDetail.setHargaJual(hargaNetto.getHargaSatuan());
						}
						if(CommonUtil.isNotNullOrEmpty(hargaNetto.getHargaNetto1())) {
							pelayananPasienDetail.setHargaNetto(hargaNetto.getHargaNetto1());
						}
						if(CommonUtil.isNotNullOrEmpty(harga.get("hargaPiutangPenjamin"))) {
							pelayananPasienDetail.setPiutangPenjamin((Double) harga.get("hargaPiutangPenjamin"));
						}
						if(CommonUtil.isNotNullOrEmpty(harga.get("hargaPiutangRumahSakit"))) {
							pelayananPasienDetail.setPiutangRumahSakit((Double) harga.get("hargaPiutangRumahSakit"));
						}
						if(CommonUtil.isNotNullOrEmpty(hargaNetto.getqtyCurrentStok())) {
							pelayananPasienDetail.setStock(hargaNetto.getqtyCurrentStok().intValue());
						}
						if(CommonUtil.isNotNullOrEmpty(harga.get("jumlah"))) {
							pelayananPasienDetail.setJumlah((Double) harga.get("jumlah"));
						}
						if(CommonUtil.isNotNullOrEmpty(pelayananPasienDetail)) {
							pelayananPasienDetailSet.add(pelayananPasienDetail);
						}
					}
					if(CommonUtil.isNotNullOrEmpty(pelayananPasienDetailSet)) {
						pelayanan.setPelayananPasienDetailSet(pelayananPasienDetailSet);
					}
				}
				//--------------------------------------------------------------------------------------
				if(CommonUtil.isNotNullOrEmpty(pelayanan)) {
					PelayananPasien pelayananPasienResult = pelayananPasienDao.save(pelayanan);
					
					if(CommonUtil.isNotNullOrEmpty(pelayananPasienResult)) {
						LogAcc log = new LogAcc();
						if(CommonUtil.isNotNullOrEmpty(pelayananPasienResult.getTglPelayanan())) {
							log.setTanggal(pelayananPasienResult.getTglPelayanan());
						}
						if(CommonUtil.isNotNullOrEmpty(pelayananPasienResult.getNoRec())) {
							log.setNoReff(pelayananPasienResult.getNoRec());
							log.setJenisTransaksi("save PelayananPasien");
						}
						if(CommonUtil.isNotNullOrEmpty(log)) {
							logAccDao.save(log);
						}
					}
				}
				//--------------------------------------------------------------------------------------
			}
		}
		if (CommonUtil.isNotNullOrEmpty(strukOrder)) {
			result.put("noOrder", strukOrder.getNoOrder());
			result.put("noOrderIntern", strukOrder.getNoOrderIntern());
		}
		return result;
	}
	
	@Transactional(readOnly=false)
	private Map<String, Object> getHarga(AntrianPasienDiPeriksa antrian, Produk produk, Double jumlah){
		Map<String, Object> result = new HashMap<>();
		
		Map<String, Object> map = pelayananPiutangRekananService.getHargaPiutangRekananProfile(antrian.getNoRec(), produk, jumlah, 0);
		if(CommonUtil.isNotNullOrEmpty(map)) {
			List<PiutangRekananProfileTemp> listPiutangRekananProfileTemp=(List<PiutangRekananProfileTemp>) map.get("list");
			Double mapHargaCito=0.0;
			Double mapHargaSatuan=0.0;
			Double mapHargaDiskon=0.0;
			Double mapHargaNetto=0.0;
			Double mapHargaPiutangRekanan=0.0;
			Double mapHargaPiutangProfile=0.0;
			for(PiutangRekananProfileTemp abcd:listPiutangRekananProfileTemp){
				mapHargaCito=Double.valueOf(abcd.getHargaCito());
				mapHargaSatuan=Double.valueOf(abcd.getHargaSatuan());
				mapHargaDiskon=Double.valueOf(abcd.getHargaDiskon());
				mapHargaNetto=Double.valueOf(abcd.getHargaNetto());
				mapHargaPiutangRekanan=Double.valueOf(abcd.getHargaPiutangRekanan());
				mapHargaPiutangProfile=Double.valueOf(abcd.getHargaPiutangProfile());
			}
			result.put("hargaSatuan", mapHargaSatuan);
			result.put("hargaJual", mapHargaSatuan);
			result.put("hargaNetto", mapHargaNetto);
			result.put("hargaPiutangPenjamin", mapHargaPiutangRekanan);
			result.put("hargaPiutangRumahSakit", mapHargaPiutangProfile);
			result.put("stok", (Double)1.00);
			result.put("jumlah", (Double)1.00);
		}
		return result;
	}

	@Override
	public Map<String, Object> updateStatusOrder(String noOrder, Byte status) {
		Map<String, Object> result = new HashMap<String, Object>();
		StrukOrder strukOrder = strukOrderDao.findByNoOrder(noOrder);
		strukOrder.setStatusOrder(status);
		strukOrderDao.save(strukOrder);
		if (CommonUtil.isNotNullOrEmpty(result)) {

			result.put("noOrder", strukOrder.getNoOrder());
		}
		return result;
	}

	@Autowired
	private BaseConverterImpl<StrukKirimVO, StrukKirim> strukKirimConverter;

	@Autowired
	private StrukKirimDao strukKirimDao;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveKirimProduk(List<KirimProdukVO> vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		for (KirimProdukVO kirimProdukVO : vo) {
			StrukKirim strukKirim = new StrukKirim();
			StrukOrder strukOrder = strukOrderDao.findOne(kirimProdukVO.getStrukOrder().getNoRec());
			AntrianPasienDiPeriksa antrianPasienDiPeriksa = antrianPasienDiPeriksaDao
					.findByStrukOrderNoRec(kirimProdukVO.getStrukOrder().getNoRec());
			strukKirim = strukKirimConverter.transferVOToModel(kirimProdukVO.getStrukKirim(), strukKirim);
			strukKirim.setNokirim(getRunningNumber("KirimProduk"));
			Ruangan ruangan = new Ruangan();
			ruangan.setId(kirimProdukVO.getStrukOrder().getRuanganTujuan().getId());
			strukKirim.setKdruangantujuan(ruangan);

			strukKirim.setKdruangan(ruangan);
			ruangan = new Ruangan();
			ruangan.setId(kirimProdukVO.getStrukOrder().getRuangan().getId());
			strukKirim.setKdruanganasal(ruangan);
			// add by askur 031120161417
			strukKirim.setQtydetailjenisproduk(0.0);
			strukKirim.setQtyproduk(0.0);
			strukKirim.setTotalbeamaterai(0.0);
			strukKirim.setTotalberatkg(0.0);
			strukKirim.setTotalbiayakirim(0.0);
			strukKirim.setTotalbiayatambahan(0.0);
			strukKirim.setTotaldiscount(0.0);
			strukKirim.setTotalhargasatuan(0.0);
			strukKirim.setTotalharusdibayar(0.0);
			strukKirim.setTotalpph(0.0);
			strukKirim.setTotalppn(0.0);
			strukKirim.setTglkirim(new Date());
			//
			strukKirimDao.save(strukKirim);

			for (OrderPelayananVO kirimProdukVO2 : kirimProdukVO.getOrderTindakan()) {
				OrderPelayanan order = orderPelayananDao.findFirstByNoRec(kirimProdukVO2.getNoRec());
				order.setQtyTerimaLast(order.getQtyProduk());
				order.setStrukKirim(strukKirim);
				orderPelayananDao.save(order);
			}

			List<OrderPelayanan> orders = orderPelayananDao.findOrderByNoOrder(strukOrder.getNoOrder());
			Boolean valid = false;
			for (OrderPelayanan orderPelayanan : orders) {
				if (orderPelayanan.getStrukKirim() == null) {
					valid = true;
					break;
				}
			}
			if (valid == true) {
				antrianPasienDiPeriksa.setStatusAntrian("1");
			} else {
				antrianPasienDiPeriksa.setStatusAntrian("2");
			}
			antrianPasienDiPeriksaDao.save(antrianPasienDiPeriksa);
		}
		if (CommonUtil.isNotNullOrEmpty(result)) {

			result.put("message", "Data Berhasil Di Simpan");
		}
		return result;
	}

	@Override
	@Transactional
	public Map<String, Object> getOrderLaboratoriumForDevice(String noOrder) {
		Map<String, Object> result = new HashMap<String, Object>();
		try {
			Pasien objectPasien = strukOrderDao.findByNoOrderIntern(noOrder).getNoCm();
			Map<String, Object> pasien = objectPasien.ToMap((Integer) 1);
			SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");
			pasien.put("tglLahir", format.format(objectPasien.getTglLahir()));
			if (objectPasien.getAgama() != null)
				pasien.put("agamaId", objectPasien.getAgama().getAgama());
			pasien.put("pendidikanId", objectPasien.getPendidikan().getNamaPendidikan());
			pasien.put("tglDaftar", format.format(objectPasien.getTglDaftar()));
			pasien.put("jenisKelaminId", objectPasien.getJenisKelamin().getJenisKelamin());
			pasien.put("dokter", strukOrderDao.findByNoOrderIntern(noOrder).getPegawaiOrder().getNamaLengkap());
			pasien.put("statusPerkawinanId", objectPasien.getStatusPerkawinan().getStatusPerkawinan());

			result.put("pasien", pasien);
			List<Object> detail = new ArrayList<>();
			List<PapPengambilanSpesimen> list = orderPelayananDao.findByStrukOrderNoOrderIntern(noOrder);
			if (list.size() == 0) {
				List<Produk> produks = orderPelayananDao.findDistinctByNoStrukOrderNoOrder(noOrder);
				for (Produk produk : produks) {
					if (produk.getBahanSample() != null) {
						Map<String, Object> data = produk.getBahanSample().ToMap(1);
						data.put("noSample", noOrder + "-" + produk.getBahanSample().getKodeExternal());
						detail.add(data);

					}
				}
			} else {
				for (PapPengambilanSpesimen papPengambilanSpesimen : list) {
					Map<String, Object> data = papPengambilanSpesimen.getBahanSample().ToMap(1);
					data.put("noSample", noOrder + "-" + papPengambilanSpesimen.getBahanSample().getKodeExternal());
					detail.add(data);
				}
			}
			List<OrderPelayanan> details = orderPelayananDao.findOrderByNoOrder(noOrder);
			List<Map<String, Object>> detailPemeriksaan = new ArrayList<>();

			for (OrderPelayanan produkDetailLaboratorium : details) {
				for (ProdukDetailLaboratorium map : produkDetailLaboratorium.getProduk().getProdukDetail()) {
					Map<String, Object> dataDetail = new HashMap<>();
					dataDetail.put("idPemeriksaan", map.getId());
					dataDetail.put("pemeriksaan", map.getDetailPemeriksaan());
					dataDetail.put("jenisPemeriksaan", map.getProduk().getJenisPeriksaPenunjang().getJenisPeriksa());
					detailPemeriksaan.add(dataDetail);
				}

			}
			result.put("detailPemeriksaan", detailPemeriksaan);
			result.put("bahanSample", detail);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Autowired
	private ProdukDetailLaboratoriumDao produkDetailLaboratoriumDao;

	@Autowired
	private HasilPemeriksaanDao hasilPemeriksaanDao;
	@Autowired
	private PasienDao pasienDao;

	@Autowired
	private StrukHasilPemeriksaanDao strukHasilPemeriksaanDao;
	@Autowired
	private HasilPemeriksaanDuploDao hasilPemeriksaanDuploDao;

	@Override
	public Map<String, Object> saveOrderLaboratoriumForDevice(String noOrder, String noSample, Integer noDetail,
			String hasil, String koment) {
		LOGGER.info("hasil masuk >>" + noDetail + " dengan nilai " + hasil + " untuk pasien " + noSample);
		Map<String, Object> result = new HashMap<String, Object>();
		List<StrukHasilPemeriksaan> list = strukHasilPemeriksaanDao.findByNoOrder(noOrder);
		StrukHasilPemeriksaan strukHasilPemeriksaan = null;
		if (list.size() > 0)
			strukHasilPemeriksaan = list.get(list.size() - 1);

		Boolean isFirst = true;
		List<HasilPemeriksaan> listHasil = new ArrayList<>();
		if (strukHasilPemeriksaan == null) {
			strukHasilPemeriksaan = new StrukHasilPemeriksaan();
			strukHasilPemeriksaan.setTglHasil(new Date());
			// strukHasilPemeriksaan.setKzeteranganLainnya(vo.get(0).getKeterangan());
			strukHasilPemeriksaan.setNoHasilPeriksa(hasilPemeriksaanService.generateNoHasilPeriksa(new Date()));
			strukHasilPemeriksaan.setStrukOrder(strukOrderDao.findByNoOrderIntern(noOrder));
			strukHasilPemeriksaanDao.save(strukHasilPemeriksaan);
			List<OrderPelayanan> details = orderPelayananDao.findOrderByNoOrder(noOrder);

			for (OrderPelayanan produkDetailLaboratorium : details) {
				for (ProdukDetailLaboratorium map : produkDetailLaboratorium.getProduk().getProdukDetail()) {
					Map<String, Object> dataDetail = new HashMap<>();
					dataDetail.put("idPemeriksaan", map.getId());
					dataDetail.put("pemeriksaan", map.getDetailPemeriksaan());
					dataDetail.put("jenisPemeriksaan", map.getProduk().getJenisPeriksaPenunjang().getJenisPeriksa());
					// detailPemeriksaan.add(dataDetail);
					HasilPemeriksaan hasilPemeriksaan = new HasilPemeriksaan();

					hasilPemeriksaan.setDetail(map);

					hasilPemeriksaan.setHasil("");

					hasilPemeriksaan.setProduk(map.getProduk());
					hasilPemeriksaan.setStrukHasilPemeriksaan(strukHasilPemeriksaan);
					listHasil.add(hasilPemeriksaan);
					hasilPemeriksaanService.save(hasilPemeriksaan);

				}

			}
		}
		HasilPemeriksaan hasilPemeriksaan = hasilPemeriksaanDao
				.findByDetailIdAndStrukHasilPemeriksaanStrukOrderNoOrderIntern(noDetail, noOrder);

		if (hasilPemeriksaan == null) {
			if (isFirst == true) {
				Boolean valid = false;
				for (HasilPemeriksaan item : listHasil) {
					if (item.getDetail().getId() == noDetail)
						hasilPemeriksaan = new HasilPemeriksaan();
				}

			}

		}
		if (hasilPemeriksaan == null) {
			result.put("message", "data tidak ditemukan");
			return result;
		}
		ProdukDetailLaboratorium detail = produkDetailLaboratoriumDao.findOne(noDetail);

		// hasilPemeriksaan =
		// hasilPemeriksaanConverter.transferVOToModel(subModel,
		// hasilPemeriksaan);
		hasilPemeriksaan.setDetail(detail);
		hasilPemeriksaan.setHasil(hasil);

		hasilPemeriksaan.setComment(koment);
		hasilPemeriksaan.setProduk(detail.getProduk());
		hasilPemeriksaan.setStrukHasilPemeriksaan(strukHasilPemeriksaan);

		hasilPemeriksaan = hasilPemeriksaanService.save(hasilPemeriksaan);

		HasilPemeriksaanDuplo duplo = new HasilPemeriksaanDuplo();
		duplo.setDetail(detail);
		duplo.setHasil(hasil);
		duplo.setTglInput(new Date());
		duplo.setHasilPemeriksaan(hasilPemeriksaan);
		duplo.setProduk(detail.getProduk());
		duplo.setStrukHasilPemeriksaan(strukHasilPemeriksaan);
		duplo = hasilPemeriksaanDuploDao.save(duplo);
		try {
			Map<String, Object> item = hasilPemeriksaan.ToMap();
			item.put("order", strukOrderDao.findByNoOrder(noOrder).ToMap());
			item.put("antrian", antrianPasienDiPeriksaDao.findByStrukOrderNoOrderIntern(noOrder).ToMap());
			result.put("message", item);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveOrderLaboratoriumForDevice(HeaderDetailHasilDeviceVO vo) {
		Map<String, Object> result = new HashMap<>();
		for (DetailHasilDeviceVO item : vo.getData()) {
			result = saveOrderLaboratoriumForDevice(item.getNoOrder(), item.getNoSample(), item.getNoDetail(),
					item.getHasil(), item.getKomen());
		}
		return result;
	}

	@Autowired
	private RegistrasiPasienService registrasiPasienService;

	@Autowired
	private RegistrasiPelayananService registrasiPelayananService;

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> getOrderFromSirs(Date from, Date until) {
		Map<String, Object> result = new HashMap<>();
		StringBuffer buffer = new StringBuffer();

		buffer.append("select lo from LisOrder lo ");
		if (CommonUtil.isNotNullOrEmpty(from) && CommonUtil.isNotNullOrEmpty(until)) {
			buffer.append(" where lo.request_dt between :from and :until  ");
		}

		Query query = em.createQuery(buffer.toString());
		SimpleDateFormat simple = new SimpleDateFormat("yyyyMMddHHmmss");
		String fromData = simple.format(from);
		String untilData = simple.format(until);
		if (CommonUtil.isNotNullOrEmpty(from) && CommonUtil.isNotNullOrEmpty(until)) {
			query.setParameter("from", fromData);
			query.setParameter("until", untilData);
		}
		List<LisOrder> list = (List<LisOrder>) query.getResultList();
		for (LisOrder lisOrder : list) {
			List<Pasien> listPasien = pasienDao.findByNoCm(lisOrder.getPid());
			Pasien pasien;
			if (listPasien.size() > 0) {
				pasien = listPasien.get(listPasien.size() - 1);
			} else {
				RegistrasiPasienVO registrasiPasienVo = new RegistrasiPasienVO();
				PasienVO pasienVo = new PasienVO();
				pasienVo.setNoCm(lisOrder.getPid());
				pasienVo.setNamaPasien(lisOrder.getPname());

				pasienVo.setTglLahir(DateUtil.toDate(lisOrder.getBirth_dt()));
				JenisKelaminVO jenisKelamin = new JenisKelaminVO();
				jenisKelamin.setId(Integer.parseInt(lisOrder.getSex()));
				pasienVo.setJenisKelamin(jenisKelamin);
				PendidikanVO pendidikan = new PendidikanVO();
				pendidikan.setId(0);
				pasienVo.setPendidikan(pendidikan);

				StatusPerkawinanVO perkawinan = new StatusPerkawinanVO();
				perkawinan.setId(0);
				pasienVo.setStatusPerkawinan(perkawinan);

				registrasiPasienVo.setPasien(pasienVo);
				registrasiPasienService.saveRegistrasiPasien(registrasiPasienVo);
			}
			RegistrasiPelayananVO registrasiPelayananVo = new RegistrasiPelayananVO();
			AsalRujukanVO asalRujukan = new AsalRujukanVO();
			asalRujukan.setId(0);
			KasusPenyakitVO kasusPenyakit = new KasusPenyakitVO();
			kasusPenyakit.setId(0);
			registrasiPelayananVo.setAsalRujukan(asalRujukan);
			registrasiPelayananVo.setKasusPenyakit(kasusPenyakit);
			RuanganVO ruangan = new RuanganVO();
			ruangan.setId(Integer.parseInt(lisOrder.getSource().split("^")[0]));
			registrasiPelayananVo.setRuangan(ruangan);
			KelompokPasienVO kelompokPasien = new KelompokPasienVO();
			kelompokPasien.setId(0);
			registrasiPelayananVo.setKelompokPasien(kelompokPasien);
			registrasiPelayananService.savePasienDafar(registrasiPelayananVo);
		}
		try {
			result.put("data", JsonUtil.ToMaps(list));
		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	/*
	 * @Autowired private HasilPemeriksaanImageDao hasilPemeriksaanImageDao;
	 * 
	 * @Override
	 * 
	 * @Transactional public Map<String, Object> saveUploadImage(String noOrder,
	 * UploadVO vo) { Map<String, Object> result = new HashMap<>();
	 * List<HasilPemeriksaanImage> data =
	 * hasilPemeriksaanImageDao.findByStrukOrderNoRecOrStrukOrderNoOrder(noOrder
	 * ,noOrder); for (HasilPemeriksaanImage hasilPemeriksaanImage : data) {
	 * hasilPemeriksaanImageDao.delete(hasilPemeriksaanImage); } StrukOrder
	 * strukOrder = new StrukOrder();
	 * strukOrder=strukOrderDao.findByNoOrder(noOrder); for (String
	 * hasilPemeriksaanImage : vo.getData()) { HasilPemeriksaanImage item = new
	 * HasilPemeriksaanImage();
	 * 
	 * item.setPath(hasilPemeriksaanImage); item.setStrukOrder(strukOrder);
	 * hasilPemeriksaanImageDao.save(item); } result.put("message",
	 * "data berhasil di simpan"); return result; }
	 */

	@Override
	public Map<String, Object> findSiklusGizi(SiklusGiziVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<SiklusGizi> siklusGizi = getSiklusGizi(vo);
		try {
			result.put("list", JsonUtil.ToMaps(siklusGizi));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	private List<SiklusGizi> getSiklusGizi(SiklusGiziVO vo) {
		List<SiklusGizi> siklusGizi = siklusGiziDao.findSiklusGizi(vo.getSiklusKe(), vo.getJenisWaktu().getId(),
				vo.getJenisDiet().getId(), vo.getKelas().getId(), vo.getBentukProduk().getId(),
				vo.getKategoriProduk().getId());
		return siklusGizi;
	}

	@Override
	public Map<String, Object> findProdukGiziMenuTambahan() {
		Map<String, Object> result = new HashMap<String, Object>();
		List<Produk> produk = produkDao.findProdukGiziMenuTambahan();
		try {
			result.put("list", JsonUtil.ToMaps(produk));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveOrderPelayananGizi(OrderProdukGiziVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		Ruangan ruangan = new Ruangan();
		ruangan.setId(Integer.valueOf(idRuanganGizi));
		AntrianPasienDiPeriksa antrian = antrianPasienDiPeriksaDao.findOne(vo.getAntrianPasienDiPeriksa().getNoRec());
		StrukOrder strukOrder = new StrukOrder();
		strukOrder.setNoOrder(StringUtil.formatNumber(
				String.valueOf(strukOrderDao.getCountByMonthAndYear(vo.getStrukOrder().getTglOrder()) + 1), 10));
		strukOrder.setTglOrder(vo.getStrukOrder().getTglOrder());
		strukOrder.setNoRegistrasi(antrian.getPasienDaftar());
		strukOrder.setIsDelivered((byte) 1);
		strukOrder.setQtyJenisProduk(1.0);
		strukOrder.setNoCm(antrian.getPasienDaftar().getPasien());
		strukOrder.setQtyProduk(1.0);
		strukOrder.setRuangan(antrian.getRuangan());
		strukOrder.setRuanganTujuan(ruangan);
		strukOrder.setTotalBeaMaterai(0.0);
		strukOrder.setTotalBiayaKirim(0.0);
		strukOrder.setTotalBiayaTambahan(0.0);
		strukOrder.setTotalHargaSatuan(0.0);
		strukOrder.setTotalDiscount(0.0);
		strukOrder.setTotalHarusDibayar(0.0);
		strukOrder.setTotalPph(0.0);
		strukOrder.setTotalPpn(0.0);
		strukOrder.setStatusOrder((byte) 0);
		strukOrder.setKeteranganOrder("Order Gizi");
		StrukOrder hasilStrukOrder = strukOrderDao.save(strukOrder);
		AntrianPasienDiPeriksa antrianPasienDiPeriksa = new AntrianPasienDiPeriksa();
		antrianPasienDiPeriksa.setStatusAntrian(StatusAntrianEnum.MENUNGGU.getVal());
		antrianPasienDiPeriksa.setRuangan(ruangan);
		antrianPasienDiPeriksa.setAsalRujukan(antrian.getAsalRujukan());
		// antrianPasienDiPeriksa.setPegawai(antrian.getPegawai());
		antrianPasienDiPeriksa.setTglRegistrasi(strukOrder.getTglOrder());
		antrianPasienDiPeriksa.setStatusPasien((byte) 1);
		antrianPasienDiPeriksa.setPasienDaftar(antrian.getPasienDaftar());
		antrianPasienDiPeriksa.setNoAntrian(antrianPasienDiPeriksaService.getFormatNumberByMonthYearRuangan(
				vo.getStrukOrder().getTglOrder(), antrianPasienDiPeriksa.getRuangan().getId()));
		antrianPasienDiPeriksa.setStrukOrder(strukOrder);
		AntrianPasienDiPeriksa hasilAntrian = antrianPasienDiPeriksaDao.save(antrianPasienDiPeriksa);
		generateSiklusGizi(vo, idRuanganGizi, hasilStrukOrder);

		result.put("dataFound", true);
		return result;
	}

	private void generateSiklusGizi(OrderProdukGiziVO vo, String idRuanganGizi, StrukOrder hasilStrukOrder) {
		for (int i = 0; i <= 4; i++) {
			JenisWaktuVO jenisWaktuL = new JenisWaktuVO();
			Integer nodeSiklus=1;
			Date tanggal = new Date();
	        SimpleDateFormat sdf = new SimpleDateFormat("dd");
	        String tglSaja=sdf.format(tanggal);
	        System.out.println("TANGGAL SAJA : "+tglSaja);			
	        nodeSiklus = ambilSiklusKe(nodeSiklus, tglSaja);
			Integer b = nodeSiklus;
			/*
			if (i == 0) {
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 0)
					b = nodeSiklus;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 1)
					b = nodeSiklus+1;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 2)
					b = nodeSiklus+1;
				jenisWaktuL.setId(i + 1);
			} else if (i == 1) {
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 0)
					b = nodeSiklus;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 1)
					b = nodeSiklus+1;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 2)
					b = nodeSiklus+1;
				jenisWaktuL.setId(i + 1);
			} else if (i == 2) {
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 0)
					b = nodeSiklus;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 1)
					b = nodeSiklus;
				if (vo.getSiklusGizi().getJenisWaktu().getId() == 2)
					b = nodeSiklus+1;
				jenisWaktuL.setId(i - 2);
			}*/
			JenisWaktu jenisW=jenisWaktuDao.findJenisWaktuBykd((byte)i);
			jenisWaktuL.setId(jenisW.getId());
			vo.getSiklusGizi().setJenisWaktu(jenisWaktuL);
			vo.getSiklusGizi().setSiklusKe(b); 
			KategoryProdukVO kategoriProduk = new KategoryProdukVO();
			//String umur=vo.getAntrianPasienDiPeriksa().getPasienDaftar().getPasien().getUmur();
			//System.out.println("UMURRRRRRRRRRRR : "+umur);
			kategoriProduk.setId(6);
			vo.getSiklusGizi().setKategoriProduk(kategoriProduk);
			System.out.println("SIKLUS GIZI 1 : "+vo.getSiklusGizi().getSiklusKe());
			System.out.println("SIKLUS GIZI 2 : "+vo.getSiklusGizi().getJenisWaktu().getId());
			List<SiklusGizi> list = getSiklusGizi(vo.getSiklusGizi());
			Ruangan ruanganAsal = new Ruangan();
			ruanganAsal.setId(vo.getRuanganAsal().getId());
			Ruangan ruanganTujuan = new Ruangan();
			ruanganTujuan.setId(Integer.valueOf(idRuanganGizi));
			JenisWaktu jenisWaktu = new JenisWaktu();
			jenisWaktu.setId(vo.getSiklusGizi().getJenisWaktu().getId());
			JenisDiet jenisDiet = new JenisDiet();
			jenisDiet.setId(vo.getSiklusGizi().getJenisDiet().getId());
			TipeMakanan typeMakanan = new TipeMakanan();
			typeMakanan.setId(vo.getSiklusGizi().getBentukProduk().getId());
			BentukProduk bentukProduk = new BentukProduk();
			bentukProduk.setId(vo.getSiklusGizi().getBentukProduk().getId());
			for (SiklusGizi abc : list) {
				OrderPelayanan orderPelayanan = new OrderPelayanan();
				orderPelayanan.setProduk(abc.getProduk());
				orderPelayanan.setJumlah(1.0);
				orderPelayanan.setTglPelayanan(vo.getTanggalPelayanan());
				getOrder(hasilStrukOrder, ruanganAsal, ruanganTujuan, jenisWaktu, jenisDiet, orderPelayanan,
						typeMakanan, abc.getBentukProduk());
				orderPelayananDao.save(orderPelayanan);
			}
			for (SiklusGiziVO abc : vo.getMenuTambahan()) {
				OrderPelayanan orderPelayanan = new OrderPelayanan();
				orderPelayanan.setProduk(produkConverter.transferVOToModel(abc.getProduk(), new Produk()));
				getOrder(hasilStrukOrder, ruanganAsal, ruanganTujuan, jenisWaktu, jenisDiet, orderPelayanan,
						typeMakanan, bentukProduk);
				orderPelayanan.setJumlah(abc.getQty());
				orderPelayanan.setTglPelayanan(vo.getTanggalPelayanan());
				orderPelayananDao.save(orderPelayanan);
			}
		}
	}

	private Integer ambilSiklusKe(Integer nodeSiklus, String tglSaja) {
		switch (tglSaja) {
		case "01":
		case "11":
		case "21":
			nodeSiklus=1;
			break;
		case "02":
		case "12":
		case "22":
			nodeSiklus=2;
			break;
		case "03":
		case "13":	
		case "23":
			nodeSiklus=3;
			break;			
		case "04":
		case "14":	
		case "24":	
			nodeSiklus=4;
			break;			
		case "05":
		case "15":	
		case "25":	
			nodeSiklus=5;
			break;			
		case "06":
		case "16":	
		case "26":	
			nodeSiklus=6;
			break;			
		case "07":
		case "17":	
		case "27":	
			nodeSiklus=7;
			break;			
		case "08":
		case "18":	
		case "28":	
			nodeSiklus=8;
			break;			
		case "09":
		case "19":
		case "29":	
			nodeSiklus=9;
			break;			
		case "10":
		case "20":	
		case "30":	
			nodeSiklus=10;
			break;			
		case "31":
			nodeSiklus=31;
			break;			
		default:
			break;
		}
		return nodeSiklus;
	}

	private void getOrder(StrukOrder hasilStrukOrder, Ruangan ruanganAsal, Ruangan ruanganTujuan, JenisWaktu jenisWaktu,
			JenisDiet jenisDiet, OrderPelayanan orderPelayanan, TipeMakanan typeMakanan, BentukProduk bentukProduk) {
		orderPelayanan.setStrukOrder(hasilStrukOrder);
		orderPelayanan.setJenisWaktu(jenisWaktu);
		orderPelayanan.setJenisDiet(jenisDiet);
		orderPelayanan.setRuangan(ruanganAsal);
		orderPelayanan.setRuanganTujuan(ruanganTujuan);
		orderPelayanan.setStatusGizi(StatusGiziEnum.MENUNGGU.getVal());
		orderPelayanan.setBentukProduk(bentukProduk);
		// orderPelayanan.setTypeMakanan(typeMakanan);
		orderPelayanan.setIsCito((byte) 0);
		orderPelayanan.setQtyProduk(0.0);
		orderPelayanan.setQtyProdukRetur(0.0);
	}

	@Override
	public Map<String, Object> getOrderPelayananGizi() {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listOrder = orderPelayananDao.findOrderPelayananGizi(Integer.valueOf(idRuanganGizi));
		for (Map<String, Object> abc : listOrder) {
			list.add(abc);
		}
		Map<String, Object> map = new HashMap<String, Object>();
		List<DiagnosaPasien> diagnosis = new ArrayList<DiagnosaPasien>();
		map.put("diagnosis", diagnosis);
		if (!list.isEmpty())
			list.add(map);
		Map<String, Object> map2 = new HashMap<String, Object>();
		List<PapAlergi> alergis = new ArrayList<PapAlergi>();
		map2.put("alergi", alergis);
		if (!list.isEmpty())
			list.add(map2);
		result.put("list", list);
		return result;
	}

	@Override
	public Map<String, Object> getOrderPelayananGiziMakanan(Integer ruanganAsalId, Integer jenisWaktuId, Date startDate,
			Date endDate) {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listOrder;
		List<Map<String, Object>> listOrder2;
		if (ruanganAsalId != null) {
			listOrder = orderPelayananDao.findOrderPelayananGizi(Integer.valueOf(idRuanganGizi), 14, ruanganAsalId,
					jenisWaktuId, startDate, endDate);
			//listOrder2 = orderPelayananDao.findOrderPelayananGizi(Integer.valueOf(idRuanganGizi), 35, ruanganAsalId,
			//		jenisWaktuId, startDate, endDate);
		} else {
			listOrder = orderPelayananDao.findOrderPelayananGiziAllRuangan(Integer.valueOf(idRuanganGizi), 14,
					startDate, endDate);
			//listOrder2 = orderPelayananDao.findOrderPelayananGiziAllRuangan(Integer.valueOf(idRuanganGizi), 35,
			//		startDate, endDate);
		}
		for (Map<String, Object> abc : listOrder) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}/*
		for (Map<String, Object> abc : listOrder2) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}*/
		result.put("list", list);
		return result;
	}

	private Map<String, Object> getAntrianInfo(Map<String, Object> abc) {
		Map<String, Object> map = new HashMap<String, Object>();
		String noRecPasienDaftar = (String) abc.get("noRecPasienDaftar");
		PasienDaftar pasienDaftar = pasienDaftarDao.findByNoRec(noRecPasienDaftar);
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<AntrianPasienDiPeriksa> antrian = antrianPasienDiPeriksaDao.findByPasienDaftarAndStrukOrderNull(noRecPasienDaftar);
		if(!antrian.isEmpty()){
			String dokter="";
			for(AntrianPasienDiPeriksa a:antrian){
				dokter=a.getPegawai().getNamaLengkap();
			}
			map.put("dokter", dokter);			
		}
		else
			map.put("dokter", "");			
		map.put("umur", pasienDaftar.getPasien().getUmur());
		return map;
	}

	@Override
	public Map<String, Object> getOrderPelayananGiziMinuman(Integer ruanganAsalId, Integer jenisWaktuId, Date startDate,
			Date endDate) {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listOrder;
		if (ruanganAsalId != null) {
			listOrder = orderPelayananDao.findOrderPelayananGizi(Integer.valueOf(idRuanganGizi), 16, ruanganAsalId,
					jenisWaktuId, startDate, endDate);
		} else {
			listOrder = orderPelayananDao.findOrderPelayananGiziAllRuangan(Integer.valueOf(idRuanganGizi), 16,
					startDate, endDate);
		}
		for (Map<String, Object> abc : listOrder) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}
		result.put("list", list);
		return result;
	}

	@Override
	public Map<String, Object> getKomposisiMakanan(Integer produkId, Integer kelasId) {
		Map<String, Object> result = new HashMap<String, Object>();
		Map<String, Object> newList = new HashMap<String, Object>();
		List<Map<String, Object>> list = orderPelayananDao.findKomposisiMakanan(produkId);
		result.put("list", list);
		return result;
	}

	@Override
	public Map<String, Object> getPemesananBahan(List<Integer> produks) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<Map<String, Object>> produk = orderPelayananDao.getPemesananBahan(produks);		
		result.put("list", produk);
		return result;
	}

	@Override
	public Map<String, Object> getProduksi(List<String> noRecOrder) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<OrderPelayanan> abc = new ArrayList<OrderPelayanan>();
		List<Integer> kelasL = new ArrayList<Integer>();
		kelasL.add(2);
		for (int i = 0; i < noRecOrder.size(); i++) {
			List<OrderPelayanan> order = orderPelayananDao.findOrderByNoRecAndJenisWaktu(noRecOrder.get(i));
			OrderPelayanan abcde = (OrderPelayanan) order.get(0);
			AntrianPasienDiPeriksa antrian = antrianPasienDiPeriksaDao
					.findByStrukOrderNoRec(abcde.getStrukOrder().getNoRec());
			abc.add(abcde);
		}
		List<String> noRecOrders = new ArrayList<String>();
		List<Integer> produksL = new ArrayList<Integer>();
		for (OrderPelayanan order : abc) {
			Integer produk = order.getProduk().getId();
			produksL.add(produk);
			noRecOrders.add(order.getNoRec());
		}
		Integer produkId = null;
		Integer kelasId = null;
		List<Map<String, Object>> produk = orderPelayananDao.getMenuProduksi(produksL,noRecOrders);
		try {
			result.put("list", JsonUtil.ToMaps(produk));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	public Map<String, Object> getProduksiBahan(List<Integer> produks) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<Map<String, Object>> produk = orderPelayananDao.getProduksiMenu(produks);
		result.put("list", produk);
		return result;
	}

	@Override
	public Map<String, Object> getKirimMenu(List<Integer> produks) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<Map<String, Object>> produk = orderPelayananDao.getKirimMenu(produks);
		result.put("list", produk);
		return result;
	}

	@Override
	@Transactional(readOnly = true)
	public Map<String, Object> getOrderKirimMenu(String noRecStrukOrder) {
		StrukOrder strukOrder = strukOrderDao.findByNoRec(noRecStrukOrder);
		Map<String, Object> maps = new HashMap<>();
		try {
			List<Map<String, Object>> temp = new ArrayList<>();
			List<OrderPelayanan> ordersProduk = orderPelayananDao.findOrderByStrukOrder(noRecStrukOrder);
			for (OrderPelayanan map : ordersProduk) {
				Map<String, Object> mapData = 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;
	}

	@Override
	public Map<String, Object> getKirimMenuGizi(List<Integer> produks, List<String> noRecOrder,
			List<Integer> jenisWaktus) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<OrderPelayanan> abc = new ArrayList<OrderPelayanan>();
		/*
		 * List<ProduksiGiziDTO> list=new ArrayList<ProduksiGiziDTO>();
		 * ProduksiGiziDTO produksiGizi=new ProduksiGiziDTO(); for(int
		 * i=0;i<produks.size();i++){ produksiGizi.setProdukId(produks.get(i));
		 * produksiGizi.setNoRecOrder(noRecOrder.get(i));
		 * produksiGizi.setJenisWaktuId(jenisWaktus.get(i));
		 * list.add(produksiGizi); }
		 */
		Kelas kelas = null;
		for (int i = 0; i < noRecOrder.size(); i++) {
			List<OrderPelayanan> order = orderPelayananDao.findOrderByNoRecAndJenisWaktu(noRecOrder.get(i));
			OrderPelayanan abcde = (OrderPelayanan) order.get(0);
			AntrianPasienDiPeriksa antrian = antrianPasienDiPeriksaDao
					.findByStrukOrderNoRec(abcde.getStrukOrder().getNoRec());
			if (antrian.getKelas() == null) {
				kelas = new Kelas();
				kelas.setId(6);
			} else {
				kelas = antrian.getKelas();
			}
			System.out.println("kelas : " + kelas.getId());
			abc.add(abcde);
		}
		List<Integer> produksL = new ArrayList<Integer>();
		for (OrderPelayanan order : abc) {
			Integer produk = order.getProduk().getId();
			produksL.add(produk);
		}
		List<Map<String, Object>> produk = orderPelayananDao.getProduksiMenu(produksL);
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		for (Map<String, Object> mapL : produk) {
			String bahan = (String) mapL.get("bahan");
			if (!bahan.contains("Pandan")) {
				listMap.add(mapL);
			}
		}
		try {
			result.put("list", JsonUtil.ToMaps(listMap));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveProduksi(OrderProdukGiziVO vos) {
		Map<String, Object> result = new HashMap<String, Object>();
		StrukHistori strukHistori = new StrukHistori();
		strukHistori.setNonHistori(getRunningNumber("Struk Histori"));
		strukHistori.setTglHistori(new Date());
		Ruangan ruangan = new Ruangan();
		ruangan.setId(Integer.valueOf(GetSettingDataFixed("idRuanganGizi")));
		strukHistori.setRuangan(ruangan);
		strukHistori.setTglAwal(new Date());
		strukHistori.setTglAhir(new Date());
		StrukHistori hasilStrukHistori = strukHistoriDao.save(strukHistori);
		ProdukProduksi produkProduksi = null;
		for (OrderPelayananVO orderPelayanan : vos.getOrderPelayanans()) {
			produkProduksi = produkProduksiDao.findByProdukId(orderPelayanan.getProduk().getId());
			OrderPelayanan op=orderPelayananDao.findById(orderPelayanan.getNoRec());
			if (produkProduksi == null) {
				produkProduksi = new ProdukProduksi();
				produkProduksi.setQtyProdukAsal(1.0);
			} else {
				produkProduksi.setQtyProdukAsal(produkProduksi.getQtyProdukAsal() + op.getJumlah());
			}
			produkProduksi.setNoHistori(hasilStrukHistori);
			produkProduksi.setProdukAsal(produkConverter.transferVOToModel(orderPelayanan.getProduk(), new Produk()));
			produkProduksi.setKeteranganLainnya("Produksi Gizi");
			produkProduksiDao.save(produkProduksi);
			List<OrderPelayanan> order = orderPelayananDao.findOrderByNoRecAndJenisWaktu(orderPelayanan.getNoRec());
			for (OrderPelayanan abc : order) {
				abc.setStatusGizi(StatusGiziEnum.PRODUKSI.getVal());
				orderPelayananDao.save(abc);
			}
			Integer produkId=orderPelayanan.getProduk().getId();
			Double jumlahPesanan=op.getJumlah();
			updateOrderStok(produkId, jumlahPesanan,ruangan,true);
		}
		result.put("dataFound", true);
		return result;
	}

	private Double updateOrderStok(Integer produkId, Double jumlah, Ruangan ruangan, Boolean updateStokOrNot) {
		Double stokBahanHasilKonversi=0.0;
		Produk p=produkDao.findOne(produkId);
		List<Map<String,Object>> listMap=orderPelayananDao.getPemesananBahan(p.getId());
		for(Map<String,Object> map:listMap){
			Double jumlahPorsi=(Double) map.get("jumlahPorsi");
			Double stok=(Double) map.get("stok");
			String bahan=(String) map.get("bahan");
			Double jumlahMenu=jumlah;
			Double total=jumlahMenu*jumlahPorsi;
			Integer satuanStandarOrder=(Integer) map.get("satuanStandarId");
			String namaSatuanStandarOrder=(String) map.get("satuanStandar");
			Integer satuanStandarStok=(Integer) map.get("satuanStokId");
			String namaSatuanStandarStok=(String) map.get("namaSatuanStok");
			Integer bahanId=(Integer) map.get("bahanId");
			Produk pBahan=produkDao.findOne(bahanId);
			Double hasiKonversi=pphpService.konversi(satuanStandarOrder, satuanStandarStok, jumlahMenu);
			Double totalHasilKonversi=total*hasiKonversi;
			stokBahanHasilKonversi=totalHasilKonversi;
			System.out.println("UPDATE KARTU STOK DAN STOKPRODUKGLOBAL : "+total+" "+namaSatuanStandarOrder+" "+bahan);
			System.out.println("UPDATE KARTU STOK DAN STOKPRODUKGLOBAL : "+stok+" "+namaSatuanStandarStok);
			System.out.println("UPDATE KARTU STOK DAN STOKPRODUKGLOBAL : hasil konversi : "+hasiKonversi);
			System.out.println("UPDATE KARTU STOK DAN STOKPRODUKGLOBAL : total hasil konversi : "+totalHasilKonversi);
			if(updateStokOrNot){
				kartuStokService.saveKartuStok(Math.ceil(hasiKonversi),pBahan, ruangan, "produksi bahan gizi ", false, new Date());
				stokProdukGlobalService.updateStokPembelianPasien(pBahan, Math.ceil(hasiKonversi), ruangan);
			}
		}
		return stokBahanHasilKonversi;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveVerifikasiGizi(String noRecOrder, Integer jenisWaktuId) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<OrderPelayanan> listOrder = orderPelayananDao.findOrderByNoRecAndJenisWaktu(noRecOrder);
		OrderPelayanan order = (OrderPelayanan) listOrder.get(0);
		order.setStatusGizi(StatusGiziEnum.VERIFIKASI.getVal());
		result.put("dataFound", true);
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePemesananBahanGizi(String noRecOrder, Integer jenisWaktuId) {
		Map<String, Object> result = new HashMap<String, Object>();
		List<OrderPelayanan> listOrder = orderPelayananDao.findOrderByNoRecAndJenisWaktu(noRecOrder);
		OrderPelayanan order = (OrderPelayanan) listOrder.get(0);
		order.setStatusGizi(StatusGiziEnum.PESAN_BAHAN.getVal());
		result.put("dataFound", true);
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveKirimMenu(OrderProdukGiziVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		for (OrderPelayananVO abc : vo.getOrderPelayanans()) {
			OrderPelayanan orderPelayanan = orderPelayananDao.findFirstByNoRec(abc.getNoRec());
			StrukOrder strukOrder = orderPelayanan.getStrukOrder();
			// OrderPelayanan orderPelayanan=new OrderPelayanan();
			PasienDaftar pasienDaftar = strukOrder.getNoRegistrasi();
			List<AntrianPasienDiPeriksa> antrian = antrianPasienDiPeriksaDao
					.findByPasienDaftar(pasienDaftar.getNoRec());
			PelayananPasien pelayanan = new PelayananPasien();
			pelayanan.setStrukOrder(strukOrder);
			pelayanan.setProduk(orderPelayanan.getProduk());
			pelayanan.setJumlah(orderPelayanan.getJumlah());
			pelayanan.setTglPelayanan(orderPelayanan.getTglPelayanan());
			pelayanan.setPasien(antrian.get(0));
			Map<String, Object> map = pelayananPiutangRekananService.getHargaPiutangRekananProfile(
					pasienDaftar.getNoRec(), orderPelayanan.getProduk(), orderPelayanan.getJumlah(), 0);
			List<PiutangRekananProfileTemp> listPiutangRekananProfileTemp = (List<PiutangRekananProfileTemp>) map
					.get("list");
			Double mapHargaCito = 0.0;
			Double mapHargaSatuan = 0.0;
			Double mapHargaDiskon = 0.0;
			Double mapHargaNetto = 0.0;
			Double mapHargaPiutangRekanan = 0.0;
			Double mapHargaPiutangProfile = 0.0;
			for (PiutangRekananProfileTemp abcd : listPiutangRekananProfileTemp) {
				mapHargaCito = Double.valueOf(abcd.getHargaCito());
				mapHargaSatuan = Double.valueOf(abcd.getHargaSatuan());
				mapHargaDiskon = Double.valueOf(abcd.getHargaDiskon());
				mapHargaNetto = Double.valueOf(abcd.getHargaNetto());
				mapHargaPiutangRekanan = Double.valueOf(abcd.getHargaPiutangRekanan());
				mapHargaPiutangProfile = Double.valueOf(abcd.getHargaPiutangProfile());
			}

			Double hargaSatuan = mapHargaSatuan;
			Double hargaJual = mapHargaSatuan;
			Double hargaNetto = mapHargaNetto;
			Double hargaPiutangPenjamin = mapHargaPiutangRekanan;
			Double hargaPiutangRumahSakit = mapHargaPiutangProfile;
			pelayanan.setHargaJual(hargaJual);
			pelayanan.setHargaSatuan(hargaSatuan);
			pelayanan.setHargaNetto(hargaNetto);
			pelayanan.setPiutangPenjamin(hargaPiutangPenjamin);
			pelayanan.setPiutangRumahSakit(hargaPiutangRumahSakit);
			pelayanan.setStock(1.0);
			pelayananPasienDao.save(pelayanan);
			List<OrderPelayanan> order = orderPelayananDao.findOrderByNoRecAndJenisWaktu(orderPelayanan.getNoRec());
			for (OrderPelayanan abcd : order) {
				abcd.setStatusGizi(StatusGiziEnum.KIRIM_MENU.getVal());
				orderPelayananDao.save(abcd);
			}
			ProdukProduksi produkProduksi = produkProduksiDao.findByProdukId(orderPelayanan.getProduk().getId());
			produkProduksi.setQtyProdukAsal(produkProduksi.getQtyProdukAsal()-orderPelayanan.getJumlah());
		}
		result.put("dataFound", true);
		return result;
	}

	@Override
	public Map<String, Object> getOrderPelayananKirimMenuGiziMakanan(Integer ruanganAsalId) {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listOrder;
		List<Map<String, Object>> listOrder2;

		Date startDate = null;
		Date endDate = null;
		DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		Calendar calendar = Calendar.getInstance();
		Date startDateL = calendar.getTime();
		calendar.add(Calendar.DAY_OF_YEAR, 1);
		Date endDateL = calendar.getTime();
		try {
			// startDate =
			// (Date)dateFormat.parse(dateFormat.format(startDateL));
			startDate = (Date) dateFormat.parse("2017/02/01 00:00:00");
			endDate = (Date) dateFormat.parse(dateFormat.format(endDateL));
		} catch (ParseException e) {
			e.printStackTrace();
		}

		dateFormat = new SimpleDateFormat("HHmmss");
		Date waktuSaja = new Date();
		Integer waktu = Integer.valueOf(dateFormat.format(waktuSaja));
		Integer jenisWaktuId = null;
		if (waktu >= 000000 && waktu <= 100000)
			jenisWaktuId = 0;
		if (waktu >= 100000 && waktu <= 140000)
			jenisWaktuId = 1;
		if (waktu >= 140000 && waktu <= 235959)
			jenisWaktuId = 2;
		/*
		 * System.out.println("oooooooooo : "+ruanganAsalId);
		 * System.out.println("oooooooooo : "+idRuanganGizi);
		 * System.out.println("oooooooooo : "+jenisWaktuId); System.out.println(
		 * "oooooooooo : "+startDate); System.out.println("oooooooooo : "
		 * +endDate);
		 */
		if (ruanganAsalId != null) {
			listOrder = orderPelayananDao.findOrderPelayananKirimMenuGizi(Integer.valueOf(idRuanganGizi), 34,
					ruanganAsalId, jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
			listOrder2 = orderPelayananDao.findOrderPelayananKirimMenuGizi(Integer.valueOf(idRuanganGizi), 35,
					ruanganAsalId, jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
		} else {
			listOrder = orderPelayananDao.findOrderPelayananKirimMenuGiziAllRuangan(Integer.valueOf(idRuanganGizi), 34,
					jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
			listOrder2 = orderPelayananDao.findOrderPelayananKirimMenuGiziAllRuangan(Integer.valueOf(idRuanganGizi), 35,
					jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
		}
		for (Map<String, Object> abc : listOrder) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}
		for (Map<String, Object> abc : listOrder2) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}
		result.put("list", list);
		return result;
	}

	private Map<String,Object> getDiagnosis(String noRecPasienDaftar) {
		List<AntrianPasienDiPeriksa> listAntrianPasienDiPeriksa=antrianPasienDiPeriksaDao.findByPasienDaftarAndStrukOrderNull(noRecPasienDaftar);
		String noRecAntrian="";
		for(AntrianPasienDiPeriksa an:listAntrianPasienDiPeriksa){
			noRecAntrian=an.getNoRec();
		}
		Map<String, Object> map = new HashMap<String, Object>();
		List<Map<String,Object>> diagnosis=diagnosaPasienDao.getDiagnosaPasienByNoRec(noRecAntrian);
		StringBuffer stringBufferDiagnosis=new StringBuffer();
		for(Map<String,Object> diag:diagnosis){
				stringBufferDiagnosis.append(diag.get("namaDiagnosa")+",");
		}
		if (!diagnosis.isEmpty()) {
			map.put("diagnosis", stringBufferDiagnosis.toString());
		}
		return map;
	}

	private Map<String,Object> getAlergis(String noRecPasienDaftar) {
		List<AntrianPasienDiPeriksa> listAntrianPasienDiPeriksa=antrianPasienDiPeriksaDao.findByPasienDaftarAndStrukOrderNull(noRecPasienDaftar);
		String noRecAntrian="";
		for(AntrianPasienDiPeriksa an:listAntrianPasienDiPeriksa){
			noRecAntrian=an.getNoRec();
		}
		Map<String, Object> map = new HashMap<String, Object>();
		List<Map<String,Object>> diagnosis=papAlergiDao.getAlergisByNoRec(noRecAntrian);
		StringBuffer stringBufferDiagnosis=new StringBuffer();
		for(Map<String,Object> diag:diagnosis){
				stringBufferDiagnosis.append(diag.get("namaAlergi")+",");
		}
		if (!diagnosis.isEmpty()) {
			map.put("alergis", stringBufferDiagnosis.toString());
		}
		return map;
	}

	@Override
	public Map<String, Object> getOrderPelayananKirimMenuGiziMinuman(Integer ruanganAsalId) {
		Map<String, Object> result = new HashMap<String, Object>();
		String idRuanganGizi = GetSettingDataFixed("idRuanganGizi");
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listOrder;

		Date startDate = null;
		Date endDate = null;
		DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd 00:00:00");
		Calendar calendar = Calendar.getInstance();
		Date startDateL = calendar.getTime();
		calendar.add(Calendar.DAY_OF_YEAR, 1);
		Date endDateL = calendar.getTime();
		try {
			// startDate =
			// (Date)dateFormat.parse(dateFormat.format(startDateL));
			startDate = (Date) dateFormat.parse("2017/02/01 00:00:00");
			endDate = (Date) dateFormat.parse(dateFormat.format(endDateL));
		} catch (ParseException e) {
			e.printStackTrace();
		}

		dateFormat = new SimpleDateFormat("HHmmss");
		Date waktuSaja = new Date();
		Integer waktu = Integer.valueOf(dateFormat.format(waktuSaja));
		Integer jenisWaktuId = null;
		if (waktu >= 000000 && waktu <= 100000)
			jenisWaktuId = 0;
		if (waktu >= 100000 && waktu <= 140000)
			jenisWaktuId = 1;
		if (waktu >= 140000 && waktu <= 235959)
			jenisWaktuId = 2;

		if (ruanganAsalId != null) {
			listOrder = orderPelayananDao.findOrderPelayananKirimMenuGizi(Integer.valueOf(idRuanganGizi), 38,
					ruanganAsalId, jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
		} else {
			listOrder = orderPelayananDao.findOrderPelayananKirimMenuGiziAllRuangan(Integer.valueOf(idRuanganGizi), 38,
					jenisWaktuId, startDate, endDate, StatusGiziEnum.PRODUKSI.getVal());
		}
		for (Map<String, Object> abc : listOrder) {
			String noRecPasienDaftar=(String) abc.get("noRecPasienDaftar");
			Map<String, Object> map = getAntrianInfo(abc);
			String status = (String) abc.get("status");
			String statusGizi = "0";
			if (status != null)
				for (StatusGiziEnum statusEnum : StatusGiziEnum.values()) {
					if (status.equals(statusEnum.getVal())) {
						statusGizi = statusEnum.name();
					}
				}
			map.put("status", statusGizi);
			abc.putAll(map);
			Map<String, Object> mapDiagnosis=getDiagnosis(noRecPasienDaftar);
			abc.putAll(mapDiagnosis);
			Map<String, Object> mapAlergis=getAlergis(noRecPasienDaftar);
			abc.putAll(mapAlergis);
			list.add(abc);
		}
		result.put("list", list);
		return result;
	}

	@Override
	public Map<String, Object> deleteOrderlaboratorium(String noRec) {
		// OrderPelayanan orderPelayanan = new OrderPelayanan();
		Map<String, Object> result = new HashMap<>();
		// orderPelayananDao.delete(noRec);
		if (CommonUtil.isNotNullOrEmpty(noRec)) {
			OrderPelayanan orderPelayanan = orderPelayananDao.findFirstByNoRec(noRec);
			if (CommonUtil.isNotNullOrEmpty(orderPelayanan)) {
				orderPelayananDao.delete(orderPelayanan);
				result.put("deleted", noRec);
			}
		}
		return result;
	}

	@Override
	public Map<String, Object> updateOrderProduk(OrderProdukVO vo) {
		return null;
	}

	@Override
	public Map<String, Object> getOrder(String noOrder) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> dataProd = orderPelayananDao.getOrderPelayananLaborat(noOrder);
		List<Map<String, Object>> resultTmp = new ArrayList<Map<String, Object>>();
		int x = 0;
		String citos = null;
		if (CommonUtil.isNotNullOrEmpty(dataProd)) {
			for (Map<String, Object> tempProd : dataProd) {
				x++;
				Map<String, Object> tempresult = new HashMap<>();
				tempresult.put("kdProfile", tempProd.get("kdprofile").toString());
				tempresult.put("id", tempProd.get("idprod").toString());
				tempresult.put("kdProduk", tempProd.get("kdprod").toString());
				tempresult.put("namaProduk", tempProd.get("nama").toString());
				tempresult.put("nilaiNormal", 0);
				tempresult.put("qtySatuKemasan", 0);
				tempresult.put("$$hashKey", "object:609");
				tempresult.put("namaBahanSample", tempProd.get("namaBs").toString());
				tempresult.put("no", x);
				tempresult.put("noRec", tempProd.get("noRec").toString());
				resultTmp.add(tempresult);
				citos = tempProd.get("cito").toString();
			}
		}
		result.put("cito", citos);
		result.put("dataOrder", resultTmp);
		return result;
	}


	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveOrderProduklab(OrderProdukVO vo, int citos) {
 		cito = citos;
 		Map<String, Object> result = saveOrderProduk(vo);
		return result;
	}

	@Override
	@Transactional(readOnly=false)
	public List<Map<String, Object>> saveVerifikasiGiziAll(List<OrderPelayananGiziDto> vos){
		List<Map<String,Object>> result=new ArrayList<Map<String,Object>>();
		for(OrderPelayananGiziDto abc:vos){
			List<OrderPelayanan> listOrder=orderPelayananDao.findOrderByNoRecAndJenisWaktu(abc.getNoRecOrder());
			OrderPelayanan order=(OrderPelayanan) listOrder.get(0);
			order.setStatusGizi(StatusGiziEnum.VERIFIKASI.getVal());
			Map<String,Object> map=new HashMap<String,Object>();
			map.put("noRecOrder", order.getNoRec());
			result.add(map);
		}
		return result;
	}

	@Override
	public List<Map<String,Object>> cekStokGiziProduksi(OrderProdukGiziVO vos) {
		List<Map<String,Object>> cek=new ArrayList<Map<String,Object>>();
		Boolean stokLess=false;
		/*
		for(Integer abc:dto.getProduks()){
			Double stok=stokProdukGlobalDao.findStokCount(abc, dto.getRuanganId());
			Produk produk=produkDao.findById(abc);
			map.put("produk", "Produk : "+produk.getNamaProduk()+" ,Stok :"+ stok);
		}
		*/
		for(OrderPelayananVO abc:vos.getOrderPelayanans()){
			OrderPelayanan orderPelayanan=orderPelayananDao.findById(abc.getNoRec());
			if(orderPelayanan!=null){
				System.out.println("PRODUK MENU NYA : "+orderPelayanan.getProduk().getId()+" "+orderPelayanan.getProduk().getNamaProduk());
				List<Map<String,Object>> listBahan=mapProdukMenuToBahanDao.getBahanFromMenu(orderPelayanan.getProduk().getId());
				for(Map<String,Object> bahan:listBahan){
					Map<String,Object> map=new HashMap<String,Object>();
					Integer bahanId=(Integer) bahan.get("bahanId");
					String namaBahan=(String) bahan.get("namaBahan");
					Integer satuanStandarStok=(Integer) bahan.get("satuanStandarProdukId");
					Integer satuanStandarOrder=(Integer) bahan.get("satuanStandarBahanId");					
					Produk produk=produkDao.findById(bahanId);
					System.out.println("PRODUK BAHAN NYA : "+produk.getId()+" "+produk.getNamaProduk());
					Double stok=stokProdukGlobalDao.findStokCount(produk.getId(), 54);
					Double orderStok=pphpService.konversi(satuanStandarOrder, satuanStandarStok, orderPelayanan.getJumlah());
					map.put("produk", "Produk : "+produk.getNamaProduk()+" ,Stok :"+ stok +" ,Order : "+orderStok);	
					System.out.println("OrderStok : "+orderStok);
					System.out.println("Stok : "+stok);
					if(orderStok>stok){
						map.put("stokLess", true);
					}else{
						map.put("stokLess", false);
					}
					if(bahanId!=12642)
					cek.add(map);
				}
			}
		}
		return cek;
	}
	
	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> updateOrderProduklab(Map<String, Object> map, int citos) {
		cito = citos;
		Map<String, Object> result = new HashMap<>();

		List<Map<String, Object>> deleteData = (List<Map<String, Object>>) map.get("deleting");
		List<Map<String, Object>> updateData = (List<Map<String, Object>>) map.get("update");
		String noOrder = (String) map.get("noOrder");
		String noRecDelet = "";
		OrderPelayanan orderPelayanan = new OrderPelayanan();

		List<Map<String, Object>> orderPelayananData = orderPelayananDao.getOrderPelayananLaborat(noOrder);
		for (Map<String, Object> tmpData : orderPelayananData) {
			noRecDelet = tmpData.get("noRec").toString();
		}

		if (CommonUtil.isNotNullOrEmpty(updateData)) {
			orderPelayanan = orderPelayananDao.findFirstByNoRec(noRecDelet);
			OrderPelayanan orderPelayanan2 = new OrderPelayanan();
			orderPelayanan2.setStrukOrder(orderPelayanan.getStrukOrder());
			orderPelayanan2.setJenisDiet(orderPelayanan.getJenisDiet());
			orderPelayanan2.setJenisWaktu(orderPelayanan.getJenisWaktu());
			orderPelayanan2.setRuanganTujuan(orderPelayanan.getRuanganTujuan());
			orderPelayanan2.setRuangan(orderPelayanan.getRuangan());
			orderPelayanan2.setNoOrder(orderPelayanan.getNoOrder());
			orderPelayanan2.setQtyProduk(orderPelayanan.getQtyProduk());
			orderPelayanan2.setQtyProdukRetur(1.0);
			orderPelayanan2.setTglPelayanan(orderPelayanan.getTglPelayanan());

			for (Map<String, Object> tmpUpData : updateData) {
				Produk prod = produkDao.findByProdukId((Integer) tmpUpData.get("id"));
				orderPelayanan2.setProduk(prod);
				orderPelayanan2.setIsCito((byte) cito);
				orderPelayananDao.save(orderPelayanan2);
				result.put("updated", tmpUpData.get("id").toString());
			}
		}
		if (CommonUtil.isNotNullOrEmpty(deleteData)) {
			for (Map<String, Object> tmpDeleteData : deleteData) {
				deleteOrderlaboratorium(tmpDeleteData.get("noRec").toString());
				result.put("deleted", tmpDeleteData.get("noRec").toString());
			}
		}
		return result;
	}

	@Override
	public List<Map<String, Object>> getAllProdukProduksiGizi(String menu) {
		List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
		list=orderProdukDaoCustom.getAllProdukProduksiGizi(menu);
		return list;
	}
}
