package com.jasamedika.medifirst2000.service.impl;

import java.text.DecimalFormat;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.jasamedika.medifirst2000.converter.BaseConverterImpl;
import com.jasamedika.medifirst2000.dao.AlamatDao;
import com.jasamedika.medifirst2000.dao.AlatDao;
import com.jasamedika.medifirst2000.dao.KartuStokDao;
import com.jasamedika.medifirst2000.dao.KelompokTransaksiDao;
import com.jasamedika.medifirst2000.dao.LaundryDao;
import com.jasamedika.medifirst2000.dao.LogAccDao;
import com.jasamedika.medifirst2000.dao.MappingJenisLinenToProdukDao;
import com.jasamedika.medifirst2000.dao.PasienDao;
import com.jasamedika.medifirst2000.dao.PlanningPelayananDao;
import com.jasamedika.medifirst2000.dao.PlanningPelayananDbhpDao;
import com.jasamedika.medifirst2000.dao.PlanningPelayananDetailDao;
import com.jasamedika.medifirst2000.dao.PlanningPelayananPetugasDao;
import com.jasamedika.medifirst2000.dao.ProdukDao;
import com.jasamedika.medifirst2000.dao.RuanganDao;
import com.jasamedika.medifirst2000.dao.RunningNumberDao;
import com.jasamedika.medifirst2000.dao.SatuanStandarDao;
import com.jasamedika.medifirst2000.dao.StokProdukDetailDao;
import com.jasamedika.medifirst2000.dao.StokProdukGlobalDao;
import com.jasamedika.medifirst2000.dao.StrukOrderDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDetailDao;
import com.jasamedika.medifirst2000.dao.StrukPlanningDao;
import com.jasamedika.medifirst2000.dao.StrukReturDao;
import com.jasamedika.medifirst2000.dao.custom.LaundryDaoCustom;
import com.jasamedika.medifirst2000.dao.custom.MappingJenisLinenToProdukDaoCustom;
import com.jasamedika.medifirst2000.dto.KapasitasBahanMesinDto;
import com.jasamedika.medifirst2000.dto.PelipatanDto;
import com.jasamedika.medifirst2000.dto.PelipatanProdukDetailDto;
import com.jasamedika.medifirst2000.dto.PenerimaanLinenDto;
import com.jasamedika.medifirst2000.dto.PenerimaanLinenExternalDto;
import com.jasamedika.medifirst2000.dto.PengeringanDto;
import com.jasamedika.medifirst2000.dto.PengeringanExternalDto;
import com.jasamedika.medifirst2000.dto.ProdukLinenExternalDto;
import com.jasamedika.medifirst2000.dto.ProsesCuciLinenDto;
import com.jasamedika.medifirst2000.dto.ProsesPembilasanDetailDto;
import com.jasamedika.medifirst2000.dto.ProsesPembilasanLinenDto;
import com.jasamedika.medifirst2000.dto.ProsesReturDto;
import com.jasamedika.medifirst2000.entities.Alamat;
import com.jasamedika.medifirst2000.entities.Alat;
import com.jasamedika.medifirst2000.entities.KelompokTransaksi;
import com.jasamedika.medifirst2000.entities.LogAcc;
import com.jasamedika.medifirst2000.entities.Pasien;
import com.jasamedika.medifirst2000.entities.Pegawai;
import com.jasamedika.medifirst2000.entities.Pendidikan;
import com.jasamedika.medifirst2000.entities.PlanningPelayanan;
import com.jasamedika.medifirst2000.entities.PlanningPelayananDbhp;
import com.jasamedika.medifirst2000.entities.PlanningPelayananDetail;
import com.jasamedika.medifirst2000.entities.PlanningPelayananPetugas;
import com.jasamedika.medifirst2000.entities.Produk;
import com.jasamedika.medifirst2000.entities.Ruangan;
import com.jasamedika.medifirst2000.entities.RunningNumber;
import com.jasamedika.medifirst2000.entities.SatuanStandar;
import com.jasamedika.medifirst2000.entities.StatusPerkawinan;
import com.jasamedika.medifirst2000.entities.StokProdukDetail;
import com.jasamedika.medifirst2000.entities.StokProdukGlobal;
import com.jasamedika.medifirst2000.entities.StrukPelayanan;
import com.jasamedika.medifirst2000.entities.StrukPelayananDetail;
import com.jasamedika.medifirst2000.entities.StrukPlanning;
import com.jasamedika.medifirst2000.entities.StrukRetur;
import com.jasamedika.medifirst2000.service.KartuStokService;
import com.jasamedika.medifirst2000.service.LaundryService;
import com.jasamedika.medifirst2000.service.LoginUserService;
import com.jasamedika.medifirst2000.service.PelayananPiutangRekananService;
import com.jasamedika.medifirst2000.service.PphpService;
import com.jasamedika.medifirst2000.service.StokProdukGlobalService;
import com.jasamedika.medifirst2000.service.StrukOrderService;
import com.jasamedika.medifirst2000.service.StrukturNoCMService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.CurrencyUtil;
import com.jasamedika.medifirst2000.util.DateUtil;
import com.jasamedika.medifirst2000.util.StringUtil;
import com.jasamedika.medifirst2000.vo.RuanganVO;

@Service("LaundryService")
public class LaundryServiceImpl extends BaseAngaranServiceImpl implements LaundryService {
	// public class LaundryServiceImpl extends BaseVoServiceImpl implements
	// LaundryService{
	@Autowired
	private RuanganDao ruanganDao;

	@Autowired
	private ProdukDao produkDao;

	@Autowired
	private SatuanStandarDao satuanStandarDao;

	@Autowired
	private StrukPelayananDao strukPelayananDao;

	@Autowired
	private StrukPelayananDetailDao strukPelayananDetailDao;

	@Autowired
	private RunningNumberDao runningNumberDao;

	@Autowired
	private LaundryDao laundryDao;

	@Autowired
	private LaundryDaoCustom laundryDaoCustom;

	@Autowired
	private StrukPlanningDao strukPlanningDao;

	@Autowired
	private PlanningPelayananDao planningPelayananDao;

	@Autowired
	private PlanningPelayananDetailDao planningPelayananDetailDao;

	@Autowired
	private PlanningPelayananDbhpDao planningPelayananDbhpDao;

	@Autowired
	private PlanningPelayananPetugasDao planningPelayananPetugasDao;

	@Autowired
	private StokProdukGlobalDao stokProdukGlobalDao;

	@Autowired
	private KartuStokService kartuStokService;
	
	@Autowired
	private KartuStokDao kartuStokDao;

	@Autowired
	private StokProdukGlobalService stokProdukGlobalService;

	@Autowired
	private PphpService pphpService;

	@Autowired
	private StokProdukDetailDao stokProdukDetailDao;

	@Autowired
	private PasienDao pasienDao;

	@Autowired
	private StrukturNoCMService strukturNoCMService;

	@Autowired
	private PelayananPiutangRekananService pelayananPiutangRekananService;

	@Autowired
	private AlamatDao alamatDao;

	@Autowired
	private StrukReturDao strukReturDao;

	@Autowired
	private LogAccDao logAccDao;

	@Autowired
	private StrukOrderService strukOrderService;

	@Autowired
	private LoginUserService loginUserService;

	@Autowired
	private BaseConverterImpl<RuanganVO, Ruangan> ruanganConverter;

	@Autowired
	private StrukOrderDao strukOrderDao;

	@Autowired
	private KelompokTransaksiDao kelompokTransaksiDao;
	
	@Autowired
	private AlatDao alatDao;
	
	@Autowired
	private MappingJenisLinenToProdukDao mappingJenisLinenToProdukDao;
	
	@Autowired
	private MappingJenisLinenToProdukDaoCustom mappingJenisLinenToProdukDaoCustom;

	
	@Override
	public List<Map<String, Object>> getAllRuangan() {
		return ruanganDao.findAllRuangan();
	}

	@Override
	public List<Map<String, Object>> getAllSatuan() {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		List<SatuanStandar> list = satuanStandarDao.findSatuanStandarKg();
		for (SatuanStandar ss : list) {
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("id", ss.getId());
			map.put("satuanStandar", ss.getSatuanStandar());
			listMap.add(map);
		}
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> getGenerateNoStruk() {
		Map<String, Object> map = new HashMap<String, Object>();
		String noStruk = getRunningNumber("StrukPelayanan");
		map.put("noStruk", noStruk);
		return map;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> savePenerimaanLinen(List<PenerimaanLinenDto> dtos) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		// Date date=new Date();
		List<StrukPelayananDetail> listStrukPelayananDetail = new ArrayList<StrukPelayananDetail>();
		// String noStruk=getRunningNumber("StrukPelayanan");
		// String noStruk2=noStruk;
		for (PenerimaanLinenDto dto : dtos) {
			Date tanggalTerima = DateUtil.toDate(dto.getTglTerima());
			Ruangan ruanganAsal = ruanganDao.findOne(dto.getRuanganId());
			Ruangan ruangan = ruanganDao.findOne(93);
			// Produk produk=produkDao.findOne(dto.getProdukId());
			StrukPelayanan strukPelayanan = new StrukPelayanan();
			if (dto.getNoRecStrukPelayanan() != null)
				strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
			StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
			strukPelayanan.setNostruk(dto.getNoStruk());
			strukPelayanan.setKdruanganasal(ruanganAsal);
			strukPelayanan.setKdruangan(ruangan);
			strukPelayanan.setQtyproduk(dto.getBerat());
			strukPelayanan.setTglstruk(tanggalTerima);
			strukPelayanan.setTglterimakiriman(tanggalTerima);
			Pegawai pegawaiPenerima = new Pegawai();
			pegawaiPenerima.setId(dto.getPetugasId());
			strukPelayanan.setKdpegawaipenerima(pegawaiPenerima);
			KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
			kelompokTransaksi.setId(6); // kelompok transaksi 6
			strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			strukPelayanan.setKdpegawaipenerima(pegawai);
			StrukPelayanan resultStrukPelayanan = strukPelayananDao.save(strukPelayanan);

			// strukPelayananDetail.setKdproduk(produk);
			strukPelayananDetail.setQtyproduk(dto.getBerat());
			SatuanStandar satuanStandar = new SatuanStandar();
			satuanStandar.setId(dto.getSatuanId());
			strukPelayananDetail.setKdsatuanstandar(satuanStandar);
			strukPelayananDetail.setNostruk(resultStrukPelayanan);
			strukPelayananDetail.setTglpelayanan(tanggalTerima);
			listStrukPelayananDetail.add(strukPelayananDetail);
		}
		Iterable<StrukPelayananDetail> listDomain = strukPelayananDetailDao.save(listStrukPelayananDetail);
		for (StrukPelayananDetail domain : listDomain) {
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("noStruk", domain.getNostruk().getNostruk());
			listMap.add(map);
		}
		return listMap;
	}

	@Transactional(readOnly = false)
	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);
			runningNumberDao.save(runningNumber);
		}
		Integer number = (runningNumber.getNomerTerbaru() + (Integer) 1);
		runningNumber.setNomerTerbaru(runningNumber.getNomerTerbaru() + (Integer) 1);
		String noOrderIntern = StringUtil.formatNumber(number.toString(), 10);
		return noOrderIntern;
	}
	
	@Transactional(readOnly=false)
	private String noUrut(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(), 10);
		runningNumberDao.save(runningNumber);	
		return noOrderIntern;
	}
	
	@Override
	public List<Map<String, Object>> getAllPenerimaanLinen(Date startPeriode, Date endPeriode) {
		List<Map<String, Object>> listMap2 = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPenerimaanLinen(startPeriode, endPeriode);
		for (Map<String, Object> mapL : listMap) {
			Map<String, Object> map = new HashMap<String, Object>();
			map = mapL;
			String noRecStrukPelayanan = (String) mapL.get("noRecStrukPelayanan");
			Integer ruanganAsalId = (Integer) mapL.get("ruanganAsalId");
			String noPlanning = (String) mapL.get("noPlanning");
			String noClosing = (String) mapL.get("noClosing");
			if (ruanganAsalId == 93) {
				map.put("status", "External");
			} else {
				map.put("status", "Internal");
			}
			if (noClosing != null) {
				map.put("statusBayar", "Sudah Bayar");
			} else {
				map.put("statusBayar", "Belum Bayar");
			}
			getProdukLinens1(map, noRecStrukPelayanan);
			listMap2.add(map);
		}
		return listMap2;
	}

	private void getProdukLinens1(Map<String, Object> map, String noRecStrukPelayanan) {
		List<Map<String, Object>> listProdukDetails2 = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listProdukDetails = strukPelayananDao.findStrukPelayananByNoRec(noRecStrukPelayanan);
		Double grantTotalHargaSatuan = 0.0;
		for (Map<String, Object> mapB : listProdukDetails) {
			Integer produkId = (Integer) mapB.get("produkId");
			Double totalHargaSatuan = 0.0;
			if (produkId != null) {
				List<Map<String, Object>> listJ = getAllSatuanPotong();
				for (Map<String, Object> mapK : listJ) {
					Integer id = (Integer) mapK.get("id");
					String satuanStandar = (String) mapK.get("satuanStandar");
					mapB.put("satuanId", id);
					mapB.put("namaSatuan", satuanStandar);
				}
				Double hargaSatuan = 0.0;
				List<Map<String, Object>> listHarga = laundryDao.getHargaLaundryByProdukKelas(produkId, 6);
				if (listHarga != null) {
					for (Map<String, Object> mapH : listHarga) {
						hargaSatuan = (Double) mapH.get("hargaSatuan");
					}
				}
				mapB.put("hargaSatuan", hargaSatuan);
				Double qtyProduk = (Double) mapB.get("qtyProduk");
				totalHargaSatuan = qtyProduk * hargaSatuan;
				mapB.put("totalHargaSatuan", totalHargaSatuan);
				listProdukDetails2.add(mapB);
			}
			grantTotalHargaSatuan = grantTotalHargaSatuan + totalHargaSatuan;
		}
		map.put("grantTotalHargaSatuan", grantTotalHargaSatuan);
		map.put("produkLinens", listProdukDetails2);
	}

	@Override
	public Map<String, Object> sendPenerimaanToPencucian(List<PenerimaanLinenDto> dtos) {
		Map<String, Object> map = new HashMap<String, Object>();
		Double count = 0.0;
		for (PenerimaanLinenDto dto : dtos) {
			count = count + dto.getBerat();
		}
		map.put("berat", count);
		map.put("penerimaanLinens", dtos);
		return map;
	}

	@Override
	public List<Map<String, Object>> getKapasitasMesin(Integer mesinId) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		listMap = laundryDao.getKapasitasMesin(mesinId);
		return listMap;
	}

	@Override
	public List<Map<String, Object>> getAllBahanFromMesinAndProses(Integer mesinId, Integer prosesCuciId) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		listMap = laundryDao.getAllBahanFromMesinAndProses(mesinId, prosesCuciId);
		return listMap;
	}

	
	//save proses cuci internal
	//by iwankasan
	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesCuci(ProsesCuciLinenDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		Date date = DateUtil.toDate(dto.getTglPencucianLinen());
		List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();

		Ruangan ruangan = ruanganDao.findOne(93); // ruangan laundry
		Produk produk = produkDao.findOne(dto.getProdukProsesCuciId());
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
		Ruangan ruanganAsal = ruanganDao.findOne(dto.getRuanganAsalId());
		strukPlanning.setKdruanganasal(ruanganAsal);
		strukPlanning.setKdruangan(ruangan);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(72); // pencucian laundry
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setTglplanning(DateUtil.toDate(dto.getTglPencucianLinen()));
		StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
		planningPelayanan(dto, 0, 0, listMap, date, listPlanningPelayananDetail, ruangan, produk, resultStrukPlanning,
				"pencucian", dto.getNoRecStrukPelayanan());
		planningPelayananDbhp(dto, listMap, resultStrukPlanning, date);
		planningPelayananPetugas(dto, listMap, date, ruangan, resultStrukPlanning);
		//updateStokRuangan(dto, ruangan);
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesCuci2(ProsesCuciLinenDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		//Ruangan ruangan = null;
		for (PenerimaanLinenDto linenDto : dto.getPenerimaanLinens()) {
			String noRecStrukPelayanan = linenDto.getNoRecStrukPelayanan();
			Date date = DateUtil.toDate(dto.getTglPencucianLinen());
			List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();

			//ruangan = ruanganDao.findOne(93); // ruangan laundry
			Ruangan ruangan = new Ruangan();
			ruangan.setId(93);
			Produk produk = produkDao.findOne(dto.getProdukProsesCuciId());
			StrukPlanning strukPlanning = new StrukPlanning();
			strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
			Ruangan ruanganAsal = ruanganDao.findOne(linenDto.getRuanganAsalId());
			strukPlanning.setKdruanganasal(ruanganAsal);
			strukPlanning.setKdruangan(ruangan);
			KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
			kelompokTransaksi.setId(72); // pencucian laundry
			strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
			strukPlanning.setTglplanning(DateUtil.toDate(dto.getTglPencucianLinen()));
			StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
			planningPelayanan2(dto, 0, 0, listMap, date, listPlanningPelayananDetail, ruangan, produk,
					resultStrukPlanning, "pencucian", noRecStrukPelayanan);
			updateStrukPelayanan(listMap, noRecStrukPelayanan);
			planningPelayananDbhp(dto, listMap, resultStrukPlanning, date);
			planningPelayananPetugas(dto, listMap, date, ruangan, resultStrukPlanning);
		}
		//updateStokRuangan(dto, ruangan);
		return listMap;
	}

	private List<Map<String, Object>> updateStrukPelayanan(List<Map<String, Object>> listMap,
			String noRecStrukPelayanan) {
		StrukPelayanan strukPelayanan = strukPelayananDao.findOne(noRecStrukPelayanan);
		StrukPelayanan updateStrukPelayanan = strukPelayananDao.save(strukPelayanan);
		if (updateStrukPelayanan != null) {
			Map<String, Object> map2 = new HashMap<String, Object>();
			map2.put("noStruk", updateStrukPelayanan.getNostruk());
			listMap.add(map2);
		}
		return listMap;
	}

	private void updateStokRuangan(ProsesCuciLinenDto dto, Ruangan ruangan) {
		for (KapasitasBahanMesinDto kapasitasBahanDto : dto.getKapasitasBahanMesins()) {
			Map<String, Object> produkBahan = produkDao
					.findProdukAndSatuanStandar(kapasitasBahanDto.getProdukBahanId());
			Integer produkId = (Integer) produkBahan.get("produkId");
			Integer satuanStandarId = (Integer) produkBahan.get("satuanStandarId");
			Produk produkBahan2 = produkDao.findOne(produkId);
			Double stok = stokProdukGlobalDao.findStokCount(produkId, ruangan.getId());
			Double orderStok = pphpService.konversi(kapasitasBahanDto.getSatuanBahanId(), satuanStandarId,
					kapasitasBahanDto.getJumlahBahan());
			if (stok > orderStok) {
				kartuStokService.saveKartuStok(orderStok, produkBahan2, ruangan, "cuci laundry", false, new Date());
				stokProdukGlobalService.updateStokPembelianPasien(produkBahan2, Math.ceil(orderStok), ruangan);
			}
		}
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> cekStokRuangan(ProsesCuciLinenDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		for (KapasitasBahanMesinDto kapasitasBahanDto : dto.getKapasitasBahanMesins()) {
			Map<String, Object> map = new HashMap<String, Object>();
			Map<String, Object> produkBahan = produkDao
					.findProdukAndSatuanStandar(kapasitasBahanDto.getProdukBahanId());
			Integer produkId = (Integer) produkBahan.get("produkId");
			String namaProduk = (String) produkBahan.get("namaProduk");
			Integer satuanStandarId = (Integer) produkBahan.get("satuanStandarId");
			Produk produkBahan2 = produkDao.findOne(produkId);
			Double stok = stokProdukGlobalDao.findStokCount(produkId, 93);
			Double orderStok = pphpService.konversi(kapasitasBahanDto.getSatuanBahanId(), satuanStandarId,
					kapasitasBahanDto.getJumlahBahan());
			if (stok == null) {
				map.put("stokLess", true);
				map.put("produk", namaProduk + " [ Stok : 0, Order Stok : " + orderStok + "]");
			} else {
				if (stok > orderStok) {
					map.put("stokLess", false);
					map.put("produk", namaProduk + " [ Stok : " + stok + ", Order Stok : " + orderStok + "]");
				} else {
					map.put("stokLess", true);
					map.put("produk", namaProduk + " [ Stok : " + stok + ", Order Stok : " + orderStok + "]");
				}
			}
			listMap.add(map);
		}
		return listMap;
	}

	private void planningPelayanan(ProsesCuciLinenDto dto, Integer jumlahCycle, Integer produkDetailId,
			List<Map<String, Object>> listMap, Date date, List<PlanningPelayananDetail> listPlanningPelayananDetail,
			Ruangan ruangan, Produk produk, StrukPlanning resultStrukPlanning, String proses,
			String noRecStrukPelayanan) {
		System.out.println("PLANNING PELAYANAN ");
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		planningPelayanan.setStrukPlaning(resultStrukPlanning);
		planningPelayanan.setTglPlanning(date);
		planningPelayanan.setTglPelayanan(date);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setTglPlanningAkhir(date);
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			planningPelayanan.setQtyProdukExec(0.0);
		else
			planningPelayanan.setQtyProdukExec(dto.getBeratLinen());
		planningPelayanan.setKeteranganExecLainnya("Eksekusi cuci");
		planningPelayanan.setTglPlanningExecAwal(date);
		planningPelayanan.setTglPlanningExecAkhir(date);
		planningPelayanan.setTglPlanningExecLast(date);
		planningPelayanan.setTglplanningExecNext(date);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		PlanningPelayanan resultPlanningpelayanan = planningPelayananDao.save(planningPelayanan);
		System.out.println("PLANNING PELAYANAN DETAIL");
		PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
		planningPelayananDetail.setPlanningPelayanan(resultPlanningpelayanan);
		Alat alat = new Alat();
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			alat.setId(1);
		else
			alat.setId(dto.getMesinId());
		planningPelayananDetail.setAlat(alat);
		planningPelayananDetail.setProduk(produk);
		if (produkDetailId == null || produkDetailId == 0) {
			planningPelayananDetail.setProdukDetail(produk);
		} else {
			Produk produkDetail = new Produk();
			produkDetail.setId(produkDetailId);
			planningPelayananDetail.setProdukDetail(produkDetail);
		}
		planningPelayananDetail.setRuangan(ruangan);
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			planningPelayananDetail.setQtyProdukDetail(0.0);
		else
			planningPelayananDetail.setQtyProdukDetail(dto.getBeratLinen());
		planningPelayananDetail.setTglPlanning(date);
		planningPelayananDetail.setTotalVolumeProdukDetail(dto.getBeratLinen());
		planningPelayananDetail.setJumlahCycle(jumlahCycle);
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setNoRec(noRecStrukPelayanan);
		planningPelayananDetail.setStrukPelayanan(strukPelayanan);
		listPlanningPelayananDetail.add(planningPelayananDetail);
		if (dto.getPenerimaanLinens() != null && !dto.getPenerimaanLinens().isEmpty()) {
			System.out.println("PENERIMAAN LINEN " + dto.getPenerimaanLinens());
			for (PenerimaanLinenDto linenDto : dto.getPenerimaanLinens()) {
				Iterable<PlanningPelayananDetail> listDomain2 = planningPelayananDetailDao
						.save(listPlanningPelayananDetail);
				for (PlanningPelayananDetail domain2 : listDomain2) {
					Map<String, Object> map2 = new HashMap<String, Object>();
					map2.put("noPlanning", domain2.getPlanningPelayanan().getStrukPlaning().getNoplanning());
					StrukPelayanan strukPelayananL = strukPelayananDao.findOne(linenDto.getNoRecStrukPelayanan());
					strukPelayananL.setNoplanning(domain2.getPlanningPelayanan().getStrukPlaning());
					StrukPelayanan updateStrukPelayanan = strukPelayananDao.save(strukPelayananL);
					if (updateStrukPelayanan != null) {
						map2.put("noStruk", updateStrukPelayanan.getNostruk());
						map2.put("noRecStrukPelayanan", linenDto.getNoRecStrukPelayanan());
						map2.put("noRecStrukPelayanan2", updateStrukPelayanan.getNoRec());
					}
					listMap.add(map2);
				}
			}
		} else {
			System.out.println("NON PENERIMAAN LINEN");
			Iterable<PlanningPelayananDetail> listDomain2 = planningPelayananDetailDao
					.save(listPlanningPelayananDetail);
			for (PlanningPelayananDetail domain2 : listDomain2) {
				Map<String, Object> map2 = new HashMap<String, Object>();
				map2.put("noPlanning", domain2.getPlanningPelayanan().getStrukPlaning().getNoplanning());
				listMap.add(map2);
			}
		}
	}

	private void planningPelayananLipat(ProsesCuciLinenDto dto, Integer jumlahCycles,
			List<PelipatanProdukDetailDto> produkDetails, List<Map<String, Object>> listMap, Date date,
			List<PlanningPelayananDetail> listPlanningPelayananDetail, Ruangan ruangan, Produk produk,
			StrukPlanning resultStrukPlanning, String proses, String noRecStrukPelayanan) {
		System.out.println("PLANNING PELAYANAN ");
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		planningPelayanan.setStrukPlaning(resultStrukPlanning);
		planningPelayanan.setTglPlanning(date);
		planningPelayanan.setTglPelayanan(date);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setTglPlanningAkhir(date);
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			planningPelayanan.setQtyProdukExec(0.0);
		else
			planningPelayanan.setQtyProdukExec(dto.getBeratLinen());
		planningPelayanan.setKeteranganExecLainnya("Eksekusi cuci");
		planningPelayanan.setTglPlanningExecAwal(date);
		planningPelayanan.setTglPlanningExecAkhir(date);
		planningPelayanan.setTglPlanningExecLast(date);
		planningPelayanan.setTglplanningExecNext(date);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		PlanningPelayanan resultPlanningpelayanan = planningPelayananDao.save(planningPelayanan);
		/////////
		for (PelipatanProdukDetailDto produkDetailDto : produkDetails) {
			Integer produkDetailId = produkDetailDto.getProdukDetailId();
			System.out.println("PLANNING PELAYANAN DETAIL");
			PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
			planningPelayananDetail.setPlanningPelayanan(resultPlanningpelayanan);
			Alat alat = new Alat();
			if (proses.equals("pengeringan") || proses.equals("pelipatan"))
				alat.setId(1);
			else
				alat.setId(dto.getMesinId());
			planningPelayananDetail.setAlat(alat);
			planningPelayananDetail.setProduk(produk);
			if (produkDetailId == null || produkDetailId == 0) {
				planningPelayananDetail.setProdukDetail(produk);
			} else {
				Produk produkDetail = new Produk();
				produkDetail.setId(produkDetailId);
				planningPelayananDetail.setProdukDetail(produkDetail);
			}
			planningPelayananDetail.setRuangan(ruangan);
			if (proses.equals("pengeringan") || proses.equals("pelipatan"))
				planningPelayananDetail.setQtyProdukDetail(0.0);
			else
				planningPelayananDetail.setQtyProdukDetail(dto.getBeratLinen());
			planningPelayananDetail.setTglPlanning(date);
			planningPelayananDetail.setTotalVolumeProdukDetail(dto.getBeratLinen());
			planningPelayananDetail.setJumlahCycle(produkDetailDto.getJumlahLipat());
			StrukPelayanan strukPelayanan = new StrukPelayanan();
			strukPelayanan.setNoRec(noRecStrukPelayanan);
			planningPelayananDetail.setStrukPelayanan(strukPelayanan);
			listPlanningPelayananDetail.add(planningPelayananDetail);
			Iterable<PlanningPelayananDetail> listDomain2 = planningPelayananDetailDao
					.save(listPlanningPelayananDetail);
			for (PlanningPelayananDetail domain2 : listDomain2) {
				Map<String, Object> map2 = new HashMap<String, Object>();
				map2.put("noPlanning", domain2.getPlanningPelayanan().getStrukPlaning().getNoplanning());
				listMap.add(map2);
			}
		}
	}

	private void planningPelayanan2(ProsesCuciLinenDto dto, Integer jumlahCycle, Integer produkDetailId,
			List<Map<String, Object>> listMap, Date date, List<PlanningPelayananDetail> listPlanningPelayananDetail,
			Ruangan ruangan, Produk produk, StrukPlanning resultStrukPlanning, String proses,
			String noRecStrukPelayanan) {
		System.out.println("PLANNING PELAYANAN ");
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		planningPelayanan.setStrukPlaning(resultStrukPlanning);
		planningPelayanan.setTglPlanning(date);
		planningPelayanan.setTglPelayanan(date);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setTglPlanningAkhir(date);
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			planningPelayanan.setQtyProdukExec(0.0);
		else
			planningPelayanan.setQtyProdukExec(dto.getBeratLinen());
		planningPelayanan.setKeteranganExecLainnya("Eksekusi cuci");
		planningPelayanan.setTglPlanningExecAwal(date);
		planningPelayanan.setTglPlanningExecAkhir(date);
		planningPelayanan.setTglPlanningExecLast(date);
		planningPelayanan.setTglplanningExecNext(date);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		PlanningPelayanan resultPlanningpelayanan = planningPelayananDao.save(planningPelayanan);
		System.out.println("PLANNING PELAYANAN DETAIL");
		PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
		planningPelayananDetail.setPlanningPelayanan(resultPlanningpelayanan);
		Alat alat = new Alat();
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			alat.setId(1);
		else
			alat.setId(dto.getMesinId());
		planningPelayananDetail.setAlat(alat);
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setNoRec(noRecStrukPelayanan);
		planningPelayananDetail.setStrukPelayanan(strukPelayanan);
		planningPelayananDetail.setProduk(produk);
		if (produkDetailId == 0) {
			planningPelayananDetail.setProdukDetail(produk);
		} else {
			Produk produkDetail = new Produk();
			produkDetail.setId(produkDetailId);
			planningPelayananDetail.setProdukDetail(produkDetail);
		}
		planningPelayananDetail.setRuangan(ruangan);
		if (proses.equals("pengeringan") || proses.equals("pelipatan"))
			planningPelayananDetail.setQtyProdukDetail(0.0);
		else
			planningPelayananDetail.setQtyProdukDetail(dto.getBeratLinen());
		planningPelayananDetail.setTglPlanning(date);
		planningPelayananDetail.setTotalVolumeProdukDetail(dto.getBeratLinen());
		planningPelayananDetail.setJumlahCycle(jumlahCycle);
		listPlanningPelayananDetail.add(planningPelayananDetail);
		Iterable<PlanningPelayananDetail> listDomain2 = planningPelayananDetailDao.save(listPlanningPelayananDetail);
		for (PlanningPelayananDetail domain2 : listDomain2) {
			Map<String, Object> map2 = new HashMap<String, Object>();
			map2.put("noPlanning", domain2.getPlanningPelayanan().getStrukPlaning().getNoplanning());
			listMap.add(map2);
		}
	}

	private void planningPelayananPetugas(ProsesCuciLinenDto dto, List<Map<String, Object>> listMap, Date date,
			Ruangan ruangan, StrukPlanning resultStrukPlanning) {
		PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
		Pegawai pegawai = new Pegawai();
		pegawai.setId(dto.getPetugasId());
		planningPelayananPetugas.setPegawai(pegawai);
		planningPelayananPetugas.setPegawaiExec(pegawai);
		planningPelayananPetugas.setStrukPlaning(resultStrukPlanning);
		planningPelayananPetugas.setRuangan(ruangan);
		planningPelayananPetugas.setTglPlanning(date);
		planningPelayananPetugas.setIsPetugasPepJawab((byte) 1);
		planningPelayananPetugas.setTglPelayanan(date);
		PlanningPelayananPetugas resultPlanningPelayananPetugas = planningPelayananPetugasDao
				.save(planningPelayananPetugas);
		if (resultPlanningPelayananPetugas != null) {
			Map<String, Object> map4 = new HashMap<String, Object>();
			map4.put("noRecPlanningPelayananPetugas", resultPlanningPelayananPetugas.getNoRec());
			listMap.add(map4);
		}
	}

	private void planningPelayananDbhp(ProsesCuciLinenDto dto, List<Map<String, Object>> listMap,
			StrukPlanning strukPlanning, Date date) {
		List<PlanningPelayananDbhp> listPlanningPelayananDbhp = new ArrayList<PlanningPelayananDbhp>();
		for (KapasitasBahanMesinDto kapasitasBahanDto : dto.getKapasitasBahanMesins()) {
			Produk produkBahan = produkDao.findOne(kapasitasBahanDto.getProdukBahanId());
			SatuanStandar satuanStandar = satuanStandarDao.findOne(kapasitasBahanDto.getSatuanBahanId());
			PlanningPelayananDbhp planningPelayananDbhp = new PlanningPelayananDbhp();
			planningPelayananDbhp.setStrukPlanning(strukPlanning);
			planningPelayananDbhp.setProduk(produkBahan);
			planningPelayananDbhp.setQtyProduk(kapasitasBahanDto.getJumlahBahan());
			planningPelayananDbhp.setSatuanStandar(satuanStandar);
			planningPelayananDbhp.setTanggalPlanning(date);
			listPlanningPelayananDbhp.add(planningPelayananDbhp);
		}
		Iterable<PlanningPelayananDbhp> listDomain3 = planningPelayananDbhpDao.save(listPlanningPelayananDbhp);
		for (PlanningPelayananDbhp domain3 : listDomain3) {
			Map<String, Object> map3 = new HashMap<String, Object>();
			map3.put("noRecPlanningPelayananDbhp", domain3.getNoRec());
			listMap.add(map3);
		}
	}

	@Override
	public List<ProsesCuciLinenDto> getAllPencucianLinen(Date startPeriode, Date endPeriode) {
		List<ProsesCuciLinenDto> listDto = new ArrayList<ProsesCuciLinenDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPencucianLinen(startPeriode, endPeriode);
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noStrukPelayanan = (String) map.get("noStrukPelayanan");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Integer mesinId = (Integer) map.get("alatId");
			String namaMesin = (String) map.get("namaAlat");
			Integer kapasitasAlat = (Integer) map.get("kapasitasAlat");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
			ProsesCuciLinenDto pencucianLinen = new ProsesCuciLinenDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setMesinId(mesinId);
			pencucianLinen.setNamaMesin(namaMesin);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setKapasitas(Double.parseDouble(String.valueOf(kapasitasAlat)));
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			Set<KapasitasBahanMesinDto> listKap = new HashSet<KapasitasBahanMesinDto>();
			for (Map<String, Object> map3 : bahanLaundry) {
				Integer produkIdL = (Integer) map3.get("produkId");
				String namaProdukL = (String) map3.get("namaProduk");
				Double jumlahBahanL = (Double) map3.get("jumlahBahan");
				Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
				String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
				KapasitasBahanMesinDto kap = new KapasitasBahanMesinDto();
				kap.setMesinId(mesinId);
				kap.setNamaMesin(namaMesin);
				kap.setProdukBahanId(produkIdL);
				kap.setNamaProdukBahan(namaProdukL);
				kap.setJumlahBahan(jumlahBahanL);
				kap.setSatuanBahanId(satuanBahanIdL);
				kap.setNamaSatuanBahan(namaSatuanBahanL);
				listKap.add(kap);
			}
			pencucianLinen.setKapasitasBahanMesins(listKap);
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			listDto.add(pencucianLinen);
		}
		return listDto;
	}

	private void getStatusAndStatusBayar(Map<String, Object> map, String noRecStrukPelayanan,
			ProsesCuciLinenDto pencucianLinen) {
		Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
		String noPlanningA = (String) map.get("noPlanning");
		String tglAmbil = (String) map.get("tglAmbil");
		String namaLengkapAmbil = (String) map.get("namaLengkapAmbil");
		String keteranganAmbil = (String) map.get("keteranganAmbil");
		if (ruanganAsalId == null || ruanganAsalId != 93) {
			pencucianLinen.setStatus("Internal");
		} else {
			pencucianLinen.setStatus("External");
		}
		List<Map<String, Object>> listK = strukPelayananDao.findStrukPelayananByNoRec(noRecStrukPelayanan);
		if (listK != null && !listK.isEmpty()) {
			for (Map<String, Object> mapK : listK) {
				String noClosing = (String) mapK.get("noClosing");
				if (noClosing == null || noClosing.equals("0")) {
					pencucianLinen.setStatusBayar("Belum Bayar");
				} else {
					pencucianLinen.setStatusBayar("Sudah Bayar");
				}
			}
		} else {
			pencucianLinen.setStatusBayar("Belum Bayar");
		}
		if (tglAmbil == null) {
			pencucianLinen.setStatusAmbil("Belum Di Ambil");
		} else {
			pencucianLinen.setStatusAmbil("Sudah Di Ambil");
		}
		pencucianLinen.setTglAmbil(tglAmbil);
		pencucianLinen.setNamaLengkapAmbil(namaLengkapAmbil);
		pencucianLinen.setKeteranganAmbil(keteranganAmbil);
	}

	private void getProdukLinens2(String noRecStrukPelayanan, ProsesCuciLinenDto pencucianLinen) {
		List<ProdukLinenExternalDto> produkLinenExternalDtos = new ArrayList<ProdukLinenExternalDto>();
		List<Map<String, Object>> listProdukDetails = strukPelayananDao.findStrukPelayananByNoRec(noRecStrukPelayanan);
		Double grantTotalHargaSatuan = 0.0;
		Double grantQtyProduk = 0.0;
		Integer pelangganId = 0;
		String namaPelanggan = "";
		for (Map<String, Object> mapB : listProdukDetails) {
			ProdukLinenExternalDto dto = new ProdukLinenExternalDto();
			String noRecStrukPelayananDetail = (String) mapB.get("noRecStrukPelayananDetail");
			Integer produkIdL = (Integer) mapB.get("produkId");
			String namaProdukL = (String) mapB.get("namaProduk");
			pelangganId = (Integer) mapB.get("pelangganId");
			namaPelanggan = (String) mapB.get("namaPelanggan");
			Double qtyProdukL = (Double) mapB.get("qtyProduk");
			Double totalHargaSatuan = 0.0;
			if (produkIdL != null) {
				dto.setProdukId(produkIdL);
				dto.setNamaProduk(namaProdukL);
				dto.setJumlah(qtyProdukL);
				List<Map<String, Object>> listJ = getAllSatuanPotong();
				for (Map<String, Object> mapK : listJ) {
					Integer id = (Integer) mapK.get("id");
					String satuanStandar = (String) mapK.get("satuanStandar");
					dto.setSatuanId(id);
					dto.setNamaSatuan(satuanStandar);
				}
				Double hargaSatuan = 0.0;
				List<Map<String, Object>> listHarga = laundryDao.getHargaLaundryByProdukKelas(produkIdL, 6);
				if (listHarga != null) {
					for (Map<String, Object> mapH : listHarga) {
						hargaSatuan = (Double) mapH.get("hargaSatuan");
					}
				}
				dto.setHargaSatuan(hargaSatuan);
				totalHargaSatuan = qtyProdukL * hargaSatuan;
				dto.setTotalHargaSatuan(totalHargaSatuan);
				dto.setNoRecStrukPelayananDetail(noRecStrukPelayananDetail);
				produkLinenExternalDtos.add(dto);
			}
			grantQtyProduk = grantQtyProduk + qtyProdukL;
			grantTotalHargaSatuan = grantTotalHargaSatuan + totalHargaSatuan;

		}
		pencucianLinen.setGrantTotalHargaSatuan(grantTotalHargaSatuan);
		pencucianLinen.setGrantQtyProduk(grantQtyProduk);
		pencucianLinen.setPelangganId(pelangganId);
		pencucianLinen.setNamaPelanggan(namaPelanggan);
		pencucianLinen.setProdukLinens(produkLinenExternalDtos);
	}

	@Override
	public Map<String, Object> sendPencucianToPembilasan(ProsesCuciLinenDto dto) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("noRecStrukPelayanan", dto.getNoRecStrukPelayanan());
		map.put("tanggal", new Date());
		map.put("mesinId", dto.getMesinId());
		map.put("namaMesin", dto.getNamaMesin());
		map.put("ruanganAsalId", dto.getRuanganAsalId());
		map.put("namaRuanganAsal", dto.getNamaRuanganAsal());
		map.put("petugasId", dto.getPetugasId());
		map.put("namaPetugas", dto.getNamaPetugas());
		map.put("kapasitas", dto.getKapasitas());
		map.put("beratLinen", dto.getBeratLinen());
		// map.put("produkProsesCuciId", dto.getProdukProsesCuciId());
		map.put("namaProdukProsesCuci", dto.getNamaProdukProsesCuci());
		return map;
	}

	@Override
	public List<Map<String, Object>> getProsesBilas(String prosesCuci) {
		String namaProdukCuci = prosesCuci;
		String splitNamaProdukCuci = namaProdukCuci.split(" ")[2];
		List<Map<String, Object>> listMap = laundryDaoCustom
				.findBilasFromCuciWithTheSamaName("%bilas%" + splitNamaProdukCuci);
		for (Map<String, Object> mapL : listMap) {
			String namaProduk = (String) mapL.get("namaProduk");
		}
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesBilas(ProsesCuciLinenDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		Date date = DateUtil.toDate(dto.getTglPencucianLinen());
		List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();

		Ruangan ruangan = ruanganDao.findOne(93); // ruangan laundry
		Produk produk = produkDao.findOne(dto.getProdukProsesCuciId());
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
		// Ruangan ruanganAsal=ruanganDao.findOne(linenDto.getRuanganId());
		// strukPlanning.setKdruanganasal(ruanganAsal);
		strukPlanning.setKdruangan(ruangan);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(73); // pembilasan laundry
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPlanning.setKdruanganasal(ruanganAsal);
		strukPlanning.setTglplanning(DateUtil.toDate(dto.getTglPencucianLinen()));
		StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
		planningPelayanan(dto, 0, 0, listMap, date, listPlanningPelayananDetail, ruangan, produk, resultStrukPlanning,
				"pembilasan", dto.getNoRecStrukPelayanan());
		planningPelayananDbhp(dto, listMap, resultStrukPlanning, date);
		planningPelayananPetugas(dto, listMap, date, ruangan, resultStrukPlanning);
		//updateStokRuangan(dto, ruangan);
		return listMap;
	}

	@Override
	public List<ProsesCuciLinenDto> getAllPembilasan(Date startPeriode, Date endPeriode) {
		List<ProsesCuciLinenDto> listDto = new ArrayList<ProsesCuciLinenDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPembilasanLinen(startPeriode, endPeriode);
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noStrukPelayanan = (String) map.get("noStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Integer mesinId = (Integer) map.get("alatId");
			String namaMesin = (String) map.get("namaAlat");
			Integer kapasitasAlat = (Integer) map.get("kapasitasAlat");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
			ProsesCuciLinenDto pencucianLinen = new ProsesCuciLinenDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
			pencucianLinen.setMesinId(mesinId);
			pencucianLinen.setNamaMesin(namaMesin);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setKapasitas(Double.parseDouble(String.valueOf(kapasitasAlat)));
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			Set<KapasitasBahanMesinDto> listKap = new HashSet<KapasitasBahanMesinDto>();
			for (Map<String, Object> map3 : bahanLaundry) {
				Integer produkIdL = (Integer) map3.get("produkId");
				String namaProdukL = (String) map3.get("namaProduk");
				Double jumlahBahanL = (Double) map3.get("jumlahBahan");
				Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
				String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
				KapasitasBahanMesinDto kap = new KapasitasBahanMesinDto();
				kap.setMesinId(mesinId);
				kap.setNamaMesin(namaMesin);
				kap.setProdukBahanId(produkIdL);
				kap.setNamaProdukBahan(namaProdukL);
				kap.setJumlahBahan(jumlahBahanL);
				kap.setSatuanBahanId(satuanBahanIdL);
				kap.setNamaSatuanBahan(namaSatuanBahanL);
				listKap.add(kap);
			}
			pencucianLinen.setKapasitasBahanMesins(listKap);
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			listDto.add(pencucianLinen);
		}
		return listDto;
	}

	@Override
	public List<ProsesCuciLinenDto> getAllPembilasan2(Date startPeriode, Date endPeriode) {
		List<ProsesCuciLinenDto> listDto = new ArrayList<ProsesCuciLinenDto>();
		List<Map<String, Object>> listPembilasan = laundryDaoCustom.getAllPembilasanLinen2(startPeriode, endPeriode);
		for (Map<String, Object> mapLp : listPembilasan) {
			String noRecStrukPelayanan1 = (String) mapLp.get("noRecStrukPelayanan");
			List<Map<String, Object>> listMap = laundryDaoCustom
					.getAllPembilasanLinenByNoRecStrukPelayanan(startPeriode, endPeriode, noRecStrukPelayanan1);
			List<ProsesPembilasanDetailDto> listDetail = new ArrayList<ProsesPembilasanDetailDto>();
			int countOk = 0, countPutih = 0, countVk = 0, countWarna = 0;
			for (Map<String, Object> map : listMap) {
				String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
				String namaProduk = (String) map.get("namaProduk");
				Integer produkId = (Integer) map.get("produkId");
				if ((namaProduk.toLowerCase().contains("linen ok") && countOk == 0)
						|| (namaProduk.toLowerCase().contains("linen putih") && countPutih == 0)
						|| (namaProduk.toLowerCase().contains("linen vk") && countVk == 0)
						|| (namaProduk.toLowerCase().contains("linen warna") && countWarna == 0)) {
					String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
					String noStrukPelayanan = (String) map.get("noStrukPelayanan");
					// String noRecStrukPlanning=(String)
					// map.get("noRecStrukPlanning");
					String noPlanning = (String) map.get("noPlanning");
					String tglPelayanan = (String) map.get("tglPelayanan");
					Integer mesinId = (Integer) map.get("alatId");
					String namaMesin = (String) map.get("namaAlat");
					Integer kapasitasAlat = (Integer) map.get("kapasitasAlat");
					Double beratLinen = (Double) map.get("beratLinen");
					// Integer produkId=(Integer) map.get("produkId");
					// String namaProduk=(String) map.get("namaProduk");
					Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
					String namaRuanganAsal = (String) map.get("namaRuanganAsal");
					List<Map<String, Object>> petugasLaundry = laundryDao
							.getAllPetugasByStrukPlanning(noRecStrukPlanning);
					List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
					ProsesPembilasanLinenDto pencucianLinen = new ProsesPembilasanLinenDto();
					pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
					pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
					pencucianLinen.setTglPencucianLinen(tglPelayanan);
					pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
					pencucianLinen.setMesinId(mesinId);
					pencucianLinen.setNamaMesin(namaMesin);
					pencucianLinen.setBeratLinen(beratLinen);
					pencucianLinen.setKapasitas(Double.parseDouble(String.valueOf(kapasitasAlat)));
					pencucianLinen.setProdukProsesCuciId(produkId);
					if (countOk == 0 || countPutih == 0 || countVk == 0 || countWarna == 0)
						pencucianLinen.setNamaProdukProsesCuci(namaProduk.replace("I ", "").replace("II ", "")
								.replace("III ", "").replace("IV ", "").replace("V ", ""));
					else
						pencucianLinen.setNamaProdukProsesCuci(namaProduk);
					pencucianLinen.setNoPlanning(noPlanning);
					pencucianLinen.setRuanganAsalId(ruanganAsalId);
					pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
					for (Map<String, Object> map2 : petugasLaundry) {
						Integer pegawaiId = (Integer) map2.get("pegawaiId");
						String namaLengkap = (String) map2.get("namaLengkap");
						pencucianLinen.setPetugasId(pegawaiId);
						pencucianLinen.setNamaPetugas(namaLengkap);
					}
					Set<KapasitasBahanMesinDto> listKap = new HashSet<KapasitasBahanMesinDto>();
					for (Map<String, Object> map3 : bahanLaundry) {
						Integer produkIdL = (Integer) map3.get("produkId");
						String namaProdukL = (String) map3.get("namaProduk");
						Double jumlahBahanL = (Double) map3.get("jumlahBahan");
						Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
						String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
						ProsesPembilasanDetailDto detailDto = new ProsesPembilasanDetailDto();
						detailDto.setProsesBilasId(produkId);
						detailDto.setNamaProsesBilas(namaProduk);
						detailDto.setBahanId(produkIdL);
						detailDto.setNamaBahan(namaProdukL);
						detailDto.setJumlah(jumlahBahanL);
						detailDto.setSatuanId(satuanBahanIdL);
						detailDto.setNamaSatuan(namaSatuanBahanL);
						listDetail.add(detailDto);
						KapasitasBahanMesinDto kap = new KapasitasBahanMesinDto();
						kap.setMesinId(mesinId);
						kap.setNamaMesin(namaMesin);
						kap.setProdukBahanId(produkIdL);
						kap.setNamaProdukBahan(namaProdukL);
						kap.setJumlahBahan(jumlahBahanL);
						kap.setSatuanBahanId(satuanBahanIdL);
						kap.setNamaSatuanBahan(namaSatuanBahanL);
						listKap.add(kap);
					}
					pencucianLinen.setKapasitasBahanMesins(listKap);
					// add status dan status bayar
					getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
					//
					getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
					//
					if (namaProduk.toLowerCase().contains("linen ok"))
						countOk = 1;
					if (namaProduk.toLowerCase().contains("linen putih"))
						countPutih = 1;
					if (namaProduk.toLowerCase().contains("linen vk"))
						countVk = 1;
					if (namaProduk.toLowerCase().contains("linen warna"))
						countWarna = 1;
					// Collections.sort(listDetail, new
					// ProsesPembilasanDetailDto());
					pencucianLinen.setDetailBilas(listDetail);
					listDto.add(pencucianLinen);
				} else {
					System.out.println("bbbbbbbbbbbbbb111111");
					List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
					for (Map<String, Object> map3 : bahanLaundry) {
						ProsesPembilasanDetailDto detailDto = new ProsesPembilasanDetailDto();
						Integer produkIdL = (Integer) map3.get("produkId");
						String namaProdukL = (String) map3.get("namaProduk");
						Double jumlahBahanL = (Double) map3.get("jumlahBahan");
						Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
						String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
						detailDto.setProsesBilasId(produkId);
						detailDto.setNamaProsesBilas(namaProduk);
						detailDto.setBahanId(produkIdL);
						detailDto.setNamaBahan(namaProdukL);
						detailDto.setJumlah(jumlahBahanL);
						detailDto.setSatuanId(satuanBahanIdL);
						detailDto.setNamaSatuan(namaSatuanBahanL);
						listDetail.add(detailDto);
					}
				}
			}
		}
		return listDto;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesPengeringan(PengeringanDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();

		Ruangan ruangan = ruanganDao.findOne(93); // ruangan laundry
		Produk produk = produkDao.findOne(10013083); // produk pengeringan
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
		// Ruangan ruanganAsal=ruanganDao.findOne(linenDto.getRuanganId());
		// strukPlanning.setKdruanganasal(ruanganAsal);
		strukPlanning.setKdruangan(ruangan);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(74); // pengeringan laundry
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPlanning.setKdruanganasal(ruanganAsal);
		strukPlanning.setTglplanning(tgl);
		StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
		planningPelayanan(dto, dto.getJumlahCycle(), 0, listMap, tgl, listPlanningPelayananDetail, ruangan, produk,
				resultStrukPlanning, "pengeringan", dto.getNoRecStrukPelayanan());
		planningPelayananPetugas(dto, listMap, tgl, ruangan, resultStrukPlanning);
		return listMap;
	}

	@Override
	public List<PengeringanDto> getAllPengeringan(Date startPeriode, Date endPeriode) {
		List<PengeringanDto> listDto = new ArrayList<PengeringanDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPengeringan(startPeriode, endPeriode);
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noStrukPelayanan = (String) map.get("noStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			Integer jumlahCycle = (Integer) map.get("jumlahCycle");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			PengeringanDto pencucianLinen = new PengeringanDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setJumlahCycle(jumlahCycle);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			listDto.add(pencucianLinen);
		}
		return listDto;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesPelipatan(PelipatanDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();

		Ruangan ruangan = ruanganDao.findOne(93); // ruangan laundry
		Produk produk = produkDao.findOne(10013084); // produk pelipatan
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
		// Ruangan ruanganAsal=ruanganDao.findOne(linenDto.getRuanganId());
		// strukPlanning.setKdruanganasal(ruanganAsal);
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruanganAsal);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(75); // pelipatan laundry
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setTglplanning(tgl);
		StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
		planningPelayanan(dto, dto.getJumlahCycle(), dto.getProdukDetailId(), listMap, tgl, listPlanningPelayananDetail,
				ruangan, produk, resultStrukPlanning, "pelipatan", dto.getNoRecStrukPelayanan());
		planningPelayananPetugas(dto, listMap, tgl, ruangan, resultStrukPlanning);
		boolean tambahStok = true;
		Integer ruanganAsalId = dto.getRuanganAsalId();
		if (ruanganAsalId == 93) {
			tambahStok = false;
		}
		
		//sesuai dengan permintaan dari ibu marlin, tgl.07.11.2018
		//penambahan stok dilakukan pada saat pelipatan,
		//krn ada beberapa linen, yg tdk masuk rollan
		
		
		
		
		//if (tambahStok) {
		//	Map<String, Object> map = new HashMap<String, Object>();
		//	Produk produkDetail = new Produk();
		//	produkDetail.setId(dto.getProdukDetailId());
		//	StokProdukDetail stokProdukDetail = stokProdukDetailDao.findbyProdukAndRuangan(produkDetail.getId(),
		//			ruangan.getId());
		//	StokProdukDetail result1 = null;
		//	if (stokProdukDetail != null) {
		//		Double qtyProduk = stokProdukDetail.getQtyProduk();
		//		Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(dto.getJumlahCycle()));
		//		stokProdukDetail.setQtyProduk(jumlah);
		//		result1 = stokProdukDetailDao.save(stokProdukDetail);
		//		map.put("noRecStokProdukDetail", result1.getNoRec());
		//	}
			//StokProdukGlobal stokProdukGlobal = stokProdukGlobalDao.findbyProdukAndRuangan(produkDetail.getId(),
			//		ruangan.getId());
			//StokProdukGlobal result2 = null;
			//if (stokProdukGlobal != null) {
			//	Double qtyProduk = stokProdukGlobal.getQtyProduk();
			//	Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(dto.getJumlahCycle()));
			//	stokProdukGlobal.setQtyProduk(jumlah);
			//	result2 = stokProdukGlobalDao.save(stokProdukGlobal);
			//	map.put("noRecStokProdukGlobal", result2.getId());
			//}
			//kartuStokService.saveKartuStok(Double.parseDouble(String.valueOf(dto.getJumlahCycle())), produkDetail,
			//		ruangan, "pelipatan laundry", true, new Date());
			//listMap.add(map);
		//} else {
		//}
		
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> prosesPelipatan2(PelipatanDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		List<PlanningPelayananDetail> listPlanningPelayananDetail = new ArrayList<PlanningPelayananDetail>();
		Integer ruanganAsalId = dto.getRuanganAsalId();
		Ruangan ruangan = ruanganDao.findOne(93); // ruangan laundry
		Produk produk = produkDao.findOne(10013084); // produk pelipatan
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setNoplanning(getRunningNumber("StrukPlanning"));
		// Ruangan ruanganAsal=ruanganDao.findOne(linenDto.getRuanganId());
		// strukPlanning.setKdruanganasal(ruanganAsal);
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruanganAsal);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(75); // pelipatan laundry
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setTglplanning(tgl);
		StrukPlanning resultStrukPlanning = strukPlanningDao.save(strukPlanning);
		if (ruanganAsalId != 93)
			planningPelayananLipat(dto, dto.getJumlahCycle(), dto.getProdukDetails(), listMap, tgl,
					listPlanningPelayananDetail, ruangan, produk, resultStrukPlanning, "pelipatan",
					dto.getNoRecStrukPelayanan());
		else
			planningPelayanan(dto, dto.getJumlahCycle(), 10013084, listMap, tgl, listPlanningPelayananDetail, ruangan,
					produk, resultStrukPlanning, "pelipatan", dto.getNoRecStrukPelayanan());
		planningPelayananPetugas(dto, listMap, tgl, ruangan, resultStrukPlanning);
		boolean tambahStok = true;

		/*
		if (ruanganAsalId == 93) {
			tambahStok = false;
		}
		
		if (tambahStok) {
			for (PelipatanProdukDetailDto produkDetailDto : dto.getProdukDetails()) {
				Map<String, Object> map = new HashMap<String, Object>();
				Produk produkDetail = new Produk();
				produkDetail.setId(produkDetailDto.getProdukDetailId());
				List<StokProdukDetail> stokProdukDetailList = stokProdukDetailDao
						.findAllbyProdukAndRuangan(produkDetail.getId(), ruangan.getId());
				StokProdukDetail stokProdukDetail = null;
				for (StokProdukDetail abc : stokProdukDetailList) {
					stokProdukDetail = new StokProdukDetail();
					stokProdukDetail.setQtyProdukOnHand(abc.getQtyProdukOnHand());
					stokProdukDetail.setHargaDiscount(abc.getHargaDiscount());
					stokProdukDetail.setHargaNetto1(abc.getHargaNetto1());
					stokProdukDetail.setHargaNetto2(abc.getHargaNetto2());
					stokProdukDetail.setPersenDiscount(abc.getPersenDiscount());
					stokProdukDetail.setProduk(abc.getProduk());
					stokProdukDetail.setRuangan(abc.getRuangan());
					stokProdukDetail.setQtyProdukOutExt(abc.getQtyProdukOutExt());
					stokProdukDetail.setQtyProdukOutInt(abc.getQtyProdukOutInt());
				}
				StokProdukDetail result1 = null;
				if (stokProdukDetail != null) {
					StokProdukDetail spd = new StokProdukDetail();
					spd.setQtyProdukOnHand(stokProdukDetail.getQtyProdukOnHand());
					AsalProduk asalProduk = new AsalProduk();
					asalProduk.setId(2);
					// spd.setAsalProduk(asalProduk);
					spd.setHargaDiscount(stokProdukDetail.getHargaDiscount());
					spd.setHargaNetto1(stokProdukDetail.getHargaNetto1());
					spd.setHargaNetto2(stokProdukDetail.getHargaNetto2());
					spd.setPersenDiscount(stokProdukDetail.getPersenDiscount());
					spd.setProduk(stokProdukDetail.getProduk());
					spd.setRuangan(stokProdukDetail.getRuangan());
					spd.setQtyProdukOutExt(stokProdukDetail.getQtyProdukOutExt());
					spd.setQtyProdukOutInt(stokProdukDetail.getQtyProdukOutInt());
					Double jumlah = Double.parseDouble(String.valueOf(produkDetailDto.getJumlahLipat()));
					spd.setQtyProduk(jumlah);
					result1 = stokProdukDetailDao.save(spd);
					map.put("noRecStokProdukDetail", result1.getNoRec());
				} else {
					StokProdukDetail spd = new StokProdukDetail();
					spd.setQtyProdukOnHand(new Double(0));
					spd.setQtyProduk(new Double(0));
					AsalProduk asalProduk = new AsalProduk();
					asalProduk.setId(2);
					// spd.setAsalProduk(asalProduk);
					spd.setHargaDiscount(new Double(0));
					spd.setHargaNetto1(new Double(0));
					spd.setHargaNetto2(new Double(0));
					spd.setPersenDiscount(new Double(0));
					Produk produkA = new Produk();
					produkA.setId(produkDetail.getId());
					spd.setProduk(produkA);
					spd.setRuangan(ruanganDao.findOne(93));
					spd.setQtyProdukOutExt(new Double(0));
					spd.setQtyProdukOutInt(new Double(0));
					Double jumlah = Double.parseDouble(String.valueOf(produkDetailDto.getJumlahLipat()));
					spd.setQtyProduk(jumlah);
					stokProdukDetailDao.save(spd);
				}
				StokProdukGlobal stokProdukGlobal = stokProdukGlobalDao.findbyProdukAndRuangan(produkDetail.getId(),
						ruangan.getId());
				StokProdukGlobal result2 = null;
				if (stokProdukGlobal != null) {
					Double qtyProduk = stokProdukGlobal.getQtyProduk();
					Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(produkDetailDto.getJumlahLipat()));
					stokProdukGlobal.setQtyProduk(jumlah);
					result2 = stokProdukGlobalDao.save(stokProdukGlobal);
					map.put("noRecStokProdukGlobal", result2.getId());
				} else {
					StokProdukGlobal spg = new StokProdukGlobal();
					spg.setQtyProdukOnHand(new Double(0));
					spg.setQtyProdukMin(new Double(0));
					spg.setQtyProdukMax(new Double(0));
					AsalProduk asalProduk = new AsalProduk();
					asalProduk.setId(2);
					// spg.setAsalProduk(asalProduk);
					spg.setHargaDiscount(new Double(0));
					spg.setHargaNetto1(new Double(0));
					spg.setHargaNetto2(new Double(0));
					spg.setPersenDiscount(new Double(0));
					Produk produkA = new Produk();
					produkA.setId(produkDetail.getId());
					spg.setProduk(produkA);
					spg.setRuangan(ruanganDao.findOne(93));
					spg.setNamaExternal(produkDetail.getNamaProduk());
					spg.setKodeExternal("0");
					spg.setReportDisplay(produkDetail.getNamaProduk());
					Double jumlah = Double.parseDouble(String.valueOf(produkDetailDto.getJumlahLipat()));
					spg.setQtyProduk(jumlah);
					stokProdukGlobalDao.save(spg);

				}
				kartuStokService.saveKartuStok(Double.parseDouble(String.valueOf(produkDetailDto.getJumlahLipat())),
						produkDetail, ruangan, "pelipatan laundry", true, new Date());
				listMap.add(map);
			}
		} else {
		}
		*/
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> cekProdukLipat(PelipatanDto dto) {
		Map<String, Object> map = new HashMap<String, Object>();
		Produk produkDetail = new Produk();
		produkDetail.setId(dto.getProdukDetailId());
		StokProdukDetail stokProdukDetail = stokProdukDetailDao.findbyProdukAndRuangan(produkDetail.getId(), 93);
		if (stokProdukDetail == null) {
			map.put("produkDetailLess", true);
			map.put("produk", dto.getNamaProdukDetail());
		} else {
			map.put("produkDetailLess", false);
			map.put("produk", dto.getNamaProdukDetail());
		}
		StokProdukGlobal stokProdukGlobal = stokProdukGlobalDao.findbyProdukAndRuangan(produkDetail.getId(), 93);
		if (stokProdukGlobal == null) {
			map.put("produkGlobalLess", true);
			map.put("produk", dto.getNamaProdukDetail());
		} else {
			map.put("produkGlobalLess", false);
			map.put("produk", dto.getNamaProdukDetail());
		}
		return map;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> cekProdukLipat2(PelipatanDto dto) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		for (PelipatanProdukDetailDto produkDetailDto : dto.getProdukDetails()) {
			Map<String, Object> map = new HashMap<String, Object>();
			Produk produkDetail = new Produk();
			produkDetail.setId(produkDetailDto.getProdukDetailId());
			StokProdukDetail stokProdukDetail = stokProdukDetailDao.findbyProdukAndRuangan(produkDetail.getId(), 93);
			if (stokProdukDetail == null) {
				map.put("produkDetailLess", true);
				map.put("produk", produkDetailDto.getNamaProdukDetail());
			} else {
				map.put("produkDetailLess", false);
				map.put("produk", produkDetailDto.getNamaProdukDetail());
			}
			StokProdukGlobal stokProdukGlobal = stokProdukGlobalDao.findbyProdukAndRuangan(produkDetail.getId(), 93);
			if (stokProdukGlobal == null) {
				map.put("produkGlobalLess", true);
				map.put("produk", produkDetailDto.getNamaProdukDetail());
			} else {
				map.put("produkGlobalLess", false);
				map.put("produk", produkDetailDto.getNamaProdukDetail());
			}
			listMap.add(map);
		}
		resultMap.put("produkDetails", listMap);
		return resultMap;
	}

	@Override
	public List<PengeringanDto> getAllPelipatan(Date startPeriode, Date endPeriode) {
		List<PengeringanDto> listDto = new ArrayList<PengeringanDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPelipatan(startPeriode, endPeriode);
		int countJumlahCycle = 0;
		int jumlahRecord = 0;
		for (Map<String, Object> map : listMap) {
			jumlahRecord++;
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noStrukPelayanan = (String) map.get("noStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			Integer jumlahCycle = (Integer) map.get("jumlahCycle");
			if (jumlahCycle == null)
				jumlahCycle = 0;
			countJumlahCycle = countJumlahCycle + jumlahCycle;
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			PengeringanDto pencucianLinen = new PengeringanDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			//
			if (ruanganAsalId != null && ruanganAsalId == 93) {
				pencucianLinen.setJumlahCycle(countJumlahCycle);
			} else {
				pencucianLinen.setJumlahCycle(jumlahCycle);
				pencucianLinen.setGrantQtyProduk(Double.valueOf(jumlahCycle));
			}
			listDto.add(pencucianLinen);
		}
		System.out.println("JUMLAHHHHHHHHHHHHHHHH RECORDDDDDDDDDDDD : " + jumlahRecord);
		return listDto;
	}

	@Override
	public List<Map<String, Object>> getProdukPelipatan() {
		List<Map<String, Object>> listMap = laundryDao.getProdukPelipatan();
		return listMap;
	}

	@Override
	public List<Map<String, Object>> getProdukPenerimaanLinenExternal() {
		List<Map<String, Object>> listMap2 = new ArrayList<Map<String, Object>>();
		/*
		 * List<Map<String,Object>>
		 * listMap=laundryDao.getProdukPenerimaanLinenExternal();
		 * for(Map<String,Object> map:listMap){ String hargaSatuan="0"; Integer
		 * produkId=(Integer) map.get("id"); Produk
		 * produk=produkDao.findById(produkId); Map<String, Object>
		 * mapHarga=pelayananPiutangRekananService.getHargaPiutangRekananProfile
		 * (null, produk, 1.0, 0); List<PiutangRekananProfileTemp>
		 * list=(List<PiutangRekananProfileTemp>) mapHarga.get("list");
		 * for(PiutangRekananProfileTemp p:list){
		 * hargaSatuan=p.getHargaSatuan(); } Map<String,Object> mapL=new
		 * HashMap<String,Object>(); mapL=map; mapL.put("hargaSatuan",
		 * hargaSatuan); listMap2.add(mapL); }
		 */
		Integer kelasId = 6;
		List<Map<String, Object>> listMap = laundryDao.getHargaLaundryByKelas(kelasId);
		for (Map<String, Object> map : listMap) {
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Double hargaSatuan = (Double) map.get("hargaSatuan");
			Map<String, Object> mapL = new HashMap<String, Object>();
			mapL.put("id", produkId);
			mapL.put("namaProduk", namaProduk);
			mapL.put("hargaSatuan", hargaSatuan);
			listMap2.add(mapL);
		}
		return listMap2;
	}

	@Override
	public List<Map<String, Object>> getDetailPenerimaanLinenExternal(String noRecStrukPelayanan) {
		return strukPelayananDao.findStrukPelayananByNoRec(noRecStrukPelayanan);
	}

	@Override
	@Transactional(readOnly = false)
	public List<Map<String, Object>> savePenerimaanLinenExternal(PenerimaanLinenExternalDto dto) {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		List<StrukPelayananDetail> listStrukPelayananDetail = new ArrayList<StrukPelayananDetail>();
		Pasien pelanggan = new Pasien();
		pelanggan.setNoCm(strukturNoCMService.getStrukturNoCm("NoCmLaundry", 15, 1));
		pelanggan.setNamaPasien(dto.getNamaPelanggan());
		pelanggan.setNoHp(dto.getNoTelp());
		pelanggan.setTglDaftar(new Date());
		Pendidikan pendidikan = new Pendidikan();
		pendidikan.setId(1);
		pelanggan.setPendidikan(pendidikan);
		StatusPerkawinan statusPerkawinan = new StatusPerkawinan();
		statusPerkawinan.setId(1);
		pelanggan.setStatusPerkawinan(statusPerkawinan);
		Set<Alamat> alamats = new HashSet<Alamat>();
		Alamat alamat = new Alamat();
		alamat.setAlamatLengkap(dto.getAlamat());
		alamats.add(alamat);
		alamat.setPasien(pelanggan);
		pelanggan.setAlamats(alamats);
		pasienDao.save(pelanggan);
		Date tanggalTerima = DateUtil.toDate(dto.getTglTerima());
		Ruangan ruanganAsal = ruanganDao.findOne(93);
		Ruangan ruangan = ruanganDao.findOne(93);
		// Produk produk=produkDao.findOne(dto.getProdukId());
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		if (dto.getNoRecStrukPelayanan() != null)
			strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		strukPelayanan.setNostruk(dto.getNoStruk());
		strukPelayanan.setKdruanganasal(ruanganAsal);
		strukPelayanan.setKdruangan(ruangan);
		strukPelayanan.setQtyproduk(dto.getBerat()); //berat
		strukPelayanan.setTglstruk(tanggalTerima);
		strukPelayanan.setKeteranganlainnya("Order Laundry External");
		strukPelayanan.setNocm(pelanggan);
		strukPelayanan.setTglterimakiriman(tanggalTerima);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(6); // kelompok transaksi 6
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		Pegawai pegawai = new Pegawai();
		pegawai.setId(dto.getPetugasId());
		strukPelayanan.setKdpegawaipenerima(pegawai);
		StrukPelayanan resultStrukPelayanan = strukPelayananDao.save(strukPelayanan);
		Double totalhargasatuan = 0.0;
		for (ProdukLinenExternalDto produk : dto.getProdukLinens()) {
			Integer produkId = produk.getProdukId();
			String namaProduk = produk.getNamaProduk();
			Double qtyProdukL = produk.getJumlah();
			Double harga = produk.getHargaSatuan();
			Produk produkL = new Produk();
			produkL.setId(produkId);
			StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
			strukPelayananDetail.setKdproduk(produkL);
			strukPelayananDetail.setQtyproduk(qtyProdukL);
			SatuanStandar satuanStandar = new SatuanStandar();
			satuanStandar.setId(dto.getSatuanId());
			strukPelayananDetail.setKdsatuanstandar(satuanStandar);
			strukPelayananDetail.setNostruk(resultStrukPelayanan);
			strukPelayananDetail.setTglpelayanan(tanggalTerima);
			strukPelayananDetail.setHargasatuan(harga);
			totalhargasatuan = totalhargasatuan + harga;
			listStrukPelayananDetail.add(strukPelayananDetail);
		}
		resultStrukPelayanan.setTotalhargasatuan(totalhargasatuan);
		strukPelayananDao.save(resultStrukPelayanan);

		// implement pencatatan jurnal (LogAcc) jika data berhasil disimpan
		if (CommonUtil.isNotNullOrEmpty(resultStrukPelayanan.getNoRec())) {
			LogAcc log = new LogAcc();
			log.setTanggal(resultStrukPelayanan.getTglstruk());
			log.setNoReff(resultStrukPelayanan.getNoRec());
			log.setJenisTransaksi("save laundry (penerimaan linen external)");
			if (CommonUtil.isNotNullOrEmpty(log)) {
				logAccDao.save(log);
			}
		}

		Iterable<StrukPelayananDetail> listDomain = strukPelayananDetailDao.save(listStrukPelayananDetail);
		for (StrukPelayananDetail domain : listDomain) {
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("noStruk", domain.getNostruk().getNostruk());
			map.put("noRecStrukPelayanan", domain.getNostruk().getNoRec());
			listMap.add(map);
		}
		return listMap;
	}

	@Override
	public ProsesCuciLinenDto sendPembilasanToPengeringan(ProsesCuciLinenDto dto) {
		ProsesCuciLinenDto listDto = new ProsesCuciLinenDto();
		List<Map<String, Object>> listMap = laundryDao.getAllDataPembilasanToPengeringan(dto.getNoRecStrukPelayanan());
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Integer mesinId = (Integer) map.get("alatId");
			String namaMesin = (String) map.get("namaAlat");
			Integer kapasitasAlat = (Integer) map.get("kapasitasAlat");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
			ProsesCuciLinenDto pencucianLinen = new ProsesCuciLinenDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setMesinId(mesinId);
			pencucianLinen.setNamaMesin(namaMesin);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setKapasitas(Double.parseDouble(String.valueOf(kapasitasAlat)));
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			Set<KapasitasBahanMesinDto> listKap = new HashSet<KapasitasBahanMesinDto>();
			for (Map<String, Object> map3 : bahanLaundry) {
				Integer produkIdL = (Integer) map3.get("produkId");
				String namaProdukL = (String) map3.get("namaProduk");
				Double jumlahBahanL = (Double) map3.get("jumlahBahan");
				Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
				String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
				KapasitasBahanMesinDto kap = new KapasitasBahanMesinDto();
				kap.setMesinId(mesinId);
				kap.setNamaMesin(namaMesin);
				kap.setProdukBahanId(produkIdL);
				kap.setNamaProdukBahan(namaProdukL);
				kap.setJumlahBahan(jumlahBahanL);
				kap.setSatuanBahanId(satuanBahanIdL);
				kap.setNamaSatuanBahan(namaSatuanBahanL);
				listKap.add(kap);
			}
			pencucianLinen.setKapasitasBahanMesins(listKap);
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			listDto = pencucianLinen;
		}
		return listDto;
	}

	@Override
	public ProsesCuciLinenDto sendPengeringanToPelipatan(ProsesCuciLinenDto dto) {
		ProsesCuciLinenDto listDto = new ProsesCuciLinenDto();
		List<Map<String, Object>> listMap = laundryDao.getAllDataPengeringanToPelipatan(dto.getNoRecStrukPelayanan());
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Integer mesinId = (Integer) map.get("alatId");
			String namaMesin = (String) map.get("namaAlat");
			Integer kapasitasAlat = (Integer) map.get("kapasitasAlat");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			List<Map<String, Object>> bahanLaundry = laundryDao.getAllBahanByStrukPlanning(noRecStrukPlanning);
			ProsesCuciLinenDto pencucianLinen = new ProsesCuciLinenDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setMesinId(mesinId);
			pencucianLinen.setNamaMesin(namaMesin);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setKapasitas(Double.parseDouble(String.valueOf(kapasitasAlat)));
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			Set<KapasitasBahanMesinDto> listKap = new HashSet<KapasitasBahanMesinDto>();
			for (Map<String, Object> map3 : bahanLaundry) {
				Integer produkIdL = (Integer) map3.get("produkId");
				String namaProdukL = (String) map3.get("namaProduk");
				Double jumlahBahanL = (Double) map3.get("jumlahBahan");
				Integer satuanBahanIdL = (Integer) map3.get("satuanStandarId");
				String namaSatuanBahanL = (String) map3.get("namaSatuanStandar");
				KapasitasBahanMesinDto kap = new KapasitasBahanMesinDto();
				kap.setMesinId(mesinId);
				kap.setNamaMesin(namaMesin);
				kap.setProdukBahanId(produkIdL);
				kap.setNamaProdukBahan(namaProdukL);
				kap.setJumlahBahan(jumlahBahanL);
				kap.setSatuanBahanId(satuanBahanIdL);
				kap.setNamaSatuanBahan(namaSatuanBahanL);
				listKap.add(kap);
			}
			pencucianLinen.setKapasitasBahanMesins(listKap);
			// add status dan status bayar
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			listDto = pencucianLinen;
		}
		return listDto;
	}

	@Override
	public Map<String, Object> sendPengeringanToPelipatanExternal(PengeringanExternalDto dto) {
		Map<String, Object> map = new HashMap<String, Object>();
		List<Map<String, Object>> listMap = strukPelayananDao.findStrukPelayananByNoRec(dto.getNoRecStrukPelayanan());
		map.put("produkDetails", listMap);
		return map;
	}

	@Override
	public List<Map<String, Object>> getAllSatuanPotong() {
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		List<SatuanStandar> list = laundryDao.findSatuanStandarPotong();
		for (SatuanStandar ss : list) {
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("id", ss.getId());
			map.put("satuanStandar", ss.getSatuanStandar());
			listMap.add(map);
		}
		return listMap;
	}

	@Override
	public Map<String, Object> getStrukOrderExternal(String noRecStrukPelayanan) {
		Map<String, Object> mapAA = new HashMap<String, Object>();
		List<Map<String, Object>> listMap = laundryDao.getStrukOrderLaundryEksternal(noRecStrukPelayanan);
		for (Map<String, Object> mapL : listMap) {
			Map<String, Object> map = new HashMap<String, Object>();
			String noRecStrukPelayananL = (String) mapL.get("noRecStrukPelayanan");
			String noClosing = (String) mapL.get("noClosing");
			String noStruk = (String) mapL.get("noStruk");
			String tglOrder = (String) mapL.get("tglTerima");
			Integer pelangganId = (Integer) mapL.get("pelangganId");
			String namaPelanggan = (String) mapL.get("namaPelanggan");
			String telepon = (String) mapL.get("telepon");
			String namaPetugas = (String) mapL.get("namaPetugas");
			map.put("noOrder", noStruk);
			map.put("tglOrder", tglOrder);
			List<Alamat> list = alamatDao.findAlamatByIdPasien(pelangganId);
			for (Alamat alamat : list) {
				map.put("alamat", alamat.getAlamatLengkap());
			}
			map.put("namaPelanggan", namaPelanggan);
			map.put("telepon", telepon);
			map.put("petugas", namaPetugas);
			if (noClosing != null) {
				map.put("statusBayar", "Sudah Bayar");
			} else {
				map.put("statusBayar", "Belum Bayar");
			}
			getProdukLinens0(map, noRecStrukPelayanan);
			mapAA = map;
		}
		return mapAA;
	}

	private void getProdukLinens0(Map<String, Object> map, String noRecStrukPelayanan) {
		List<Map<String, Object>> listProdukDetails2 = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> listProdukDetails = strukPelayananDao.findStrukPelayananByNoRec(noRecStrukPelayanan);
		Double grantTotalHargaSatuan = 0.0;
		for (Map<String, Object> mapB : listProdukDetails) {
			Map<String, Object> mapQ = new HashMap<String, Object>();
			Integer produkId = (Integer) mapB.get("produkId");
			String namaProduk = (String) mapB.get("namaProduk");
			Double jumlah = (Double) mapB.get("qtyProduk");
			Double totalHargaSatuan = 0.0;
			if (produkId != null) {
				List<Map<String, Object>> listJ = getAllSatuanPotong();
				for (Map<String, Object> mapK : listJ) {
					Integer id = (Integer) mapK.get("id");
					String satuanStandar = (String) mapK.get("satuanStandar");
					mapB.put("satuanId", id);
					mapB.put("namaSatuan", satuanStandar);
				}
				Double hargaSatuan = 0.0;
				List<Map<String, Object>> listHarga = laundryDao.getHargaLaundryByProdukKelas(produkId, 6);
				if (listHarga != null) {
					for (Map<String, Object> mapH : listHarga) {
						hargaSatuan = (Double) mapH.get("hargaSatuan");
					}
				}
				mapB.put("hargaSatuan", hargaSatuan);
				Double qtyProduk = (Double) mapB.get("qtyProduk");
				totalHargaSatuan = qtyProduk * hargaSatuan;
				mapB.put("totalHargaSatuan", totalHargaSatuan);
				mapQ.put("namaLinen", namaProduk);
				mapQ.put("jumlah", jumlah);
				mapQ.put("hargaSatuan", CurrencyUtil.getPriceInINA(hargaSatuan));
				mapQ.put("totalHarga", CurrencyUtil.getPriceInINA(totalHargaSatuan));
				listProdukDetails2.add(mapQ);
			}
			grantTotalHargaSatuan = grantTotalHargaSatuan + totalHargaSatuan;
		}
		map.put("grantTotal", grantTotalHargaSatuan);
		map.put("produkLinens", listProdukDetails2);
	}

	@Override
	public List<PengeringanDto> getAllPengambilanLinenEksternal(String namaPelanggan, Date startPeriode,
			Date endPeriode) {
		List<PengeringanDto> listDto = new ArrayList<PengeringanDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllPengambilanLinenEksternal(namaPelanggan,
				startPeriode, endPeriode);
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noStrukPelayanan = (String) map.get("noStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			Integer pelangganId = (Integer) map.get("pelangganId");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			String tglAmbil = (String) map.get("tglAmbil");
			String namaLengkapAmbil = (String) map.get("namaLengkapAmbil");
			String keteranganAmbil = (String) map.get("keteranganAmbil");

			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			Integer jumlahCycle = (Integer) map.get("jumlahCycle");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			PengeringanDto pencucianLinen = new PengeringanDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setNoStrukPelayanan(noStrukPelayanan);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			if (tglAmbil != null) {
				pencucianLinen.setTglAmbil(tglAmbil);
			} else {
				pencucianLinen.setTglAmbil("");
			}
			if (namaLengkapAmbil != null)
				pencucianLinen.setNamaLengkapAmbil(namaLengkapAmbil);
			else
				pencucianLinen.setNamaLengkapAmbil("");
			if (keteranganAmbil != null)
				pencucianLinen.setKeteranganAmbil(keteranganAmbil);
			else
				pencucianLinen.setKeteranganAmbil("");
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			List<Alamat> list = alamatDao.findAlamatByIdPasien(pelangganId);
			if (!list.isEmpty()) {
				for (Alamat alamat : list) {
					pencucianLinen.setAlamat(alamat.getAlamatLengkap());
				}
			} else {
				pencucianLinen.setAlamat("");
			}
			// add status dan status bayar dan ambil
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			pencucianLinen.setJumlahCycle(jumlahCycle);
			listDto.add(pencucianLinen);
		}
		return listDto;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> prosesPengambilan(ProsesCuciLinenDto dto) {
		Map<String, Object> listMap = new HashMap<String, Object>();
		StrukPelayanan strukPelayanan = strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		strukPelayanan.setNamaLengkapAmbil(dto.getNamaLengkapAmbil());
		strukPelayanan.setTglAmbil(DateUtil.toDate(dto.getTglAmbil()));
		if (dto.getKeteranganAmbil() != null)
			strukPelayanan.setKeteranganAmbil(dto.getKeteranganAmbil());
		StrukPelayanan result = strukPelayananDao.save(strukPelayanan);
		listMap.put("data", result.getNoRec());
		return listMap;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> prosesReturLaundry(ProsesReturDto dto) {
		Map<String, Object> map = new HashMap<String, Object>();
		StrukRetur retur = new StrukRetur();
		retur.setNoRetur(getRunningNumber("Struk Retur"));
		retur.setTglRetur(DateUtil.toDate(dto.getTglRetur()));
		retur.setKeteranganAlasan(dto.getKeteranganAlasan());
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(6);
		retur.setKelompokTransaksi(kelompokTransaksi);
		Ruangan ruangan = new Ruangan();
		ruangan.setId(93);
		retur.setRuangan(ruangan);
		StrukRetur resultStrukRetur = strukReturDao.save(retur);
		map.put("NoStrukRetur", resultStrukRetur.getNoRec());
		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
		for (ProdukLinenExternalDto produk : dto.getProdukLinens()) {
			if (produk.getJumlahRetur() != null) {
				Map<String, Object> mapDetail = new HashMap<String, Object>();
				StrukPelayananDetail strukDetail = laundryDao.findByStrukPelStrukPelDetailProduk(
						dto.getNoRecStrukPelayanan(), produk.getNoRecStrukPelayananDetail(), produk.getProdukId());
				StrukPelayananDetail strukDetailNew = new StrukPelayananDetail();
				// strukDetailNew=strukDetail;
				strukDetailNew.setQtyprodukretur(produk.getJumlahRetur());
				strukDetailNew.setHargasatuan(produk.getHargaSatuan());
				strukDetailNew.setHarganetto(produk.getHargaSatuan());
				strukDetailNew.setStrukPelayananDetail(strukDetail);
				strukDetailNew.setNoretur(retur);
				strukDetailNew.setNostruk(strukDetail.getNostruk());
				StrukPelayananDetail resultStrukPDetail = strukPelayananDetailDao.save(strukDetailNew);
				mapDetail.put("NoRecStrukPelayananDetail", resultStrukPDetail.getNoRec());
				listMap.add(mapDetail);
			}
		}
		map.put("NoStrukRetur", resultStrukRetur.getNoRetur());
		map.put("NoStrukPelayananDetails", listMap);
		return map;
	}

	@Override
	public PengeringanDto sendPengambilanLinenToReturLinen(PengeringanDto dto) {
		PengeringanDto listDto = new PengeringanDto();
		List<Map<String, Object>> listMap = laundryDao.getAllDataPengambilanToRetur(dto.getNoRecStrukPelayanan());
		for (Map<String, Object> map : listMap) {
			String noRecStrukPelayanan = (String) map.get("noRecStrukPelayanan");
			String noRecStrukPlanning = (String) map.get("noRecStrukPlanning");
			String noPlanning = (String) map.get("noPlanning");
			String tglPelayanan = (String) map.get("tglPelayanan");
			Double beratLinen = (Double) map.get("beratLinen");
			Integer produkId = (Integer) map.get("produkId");
			String namaProduk = (String) map.get("namaProduk");
			Integer pelangganId = (Integer) map.get("pelangganId");
			String namaPelanggan = (String) map.get("namaPelanggan");
			String noTelepon = (String) map.get("noTelepon");
			Integer ruanganAsalId = (Integer) map.get("ruanganAsalId");
			String namaRuanganAsal = (String) map.get("namaRuanganAsal");
			Integer jumlahCycle = (Integer) map.get("jumlahCycle");
			List<Map<String, Object>> petugasLaundry = laundryDao.getAllPetugasByStrukPlanning(noRecStrukPlanning);
			PengeringanDto pencucianLinen = new PengeringanDto();
			pencucianLinen.setNoRecStrukPelayanan(noRecStrukPelayanan);
			pencucianLinen.setNoRecStrukPlanning(noRecStrukPlanning);
			pencucianLinen.setTglPencucianLinen(tglPelayanan);
			pencucianLinen.setBeratLinen(beratLinen);
			pencucianLinen.setProdukProsesCuciId(produkId);
			pencucianLinen.setNamaProdukProsesCuci(namaProduk);
			pencucianLinen.setNoPlanning(noPlanning);
			pencucianLinen.setRuanganAsalId(ruanganAsalId);
			pencucianLinen.setNamaRuanganAsal(namaRuanganAsal);
			pencucianLinen.setPelangganId(pelangganId);
			pencucianLinen.setNamaPelanggan(namaPelanggan);
			pencucianLinen.setNoTelepon(noTelepon);
			for (Map<String, Object> map2 : petugasLaundry) {
				Integer pegawaiId = (Integer) map2.get("pegawaiId");
				String namaLengkap = (String) map2.get("namaLengkap");
				pencucianLinen.setPetugasId(pegawaiId);
				pencucianLinen.setNamaPetugas(namaLengkap);
			}
			List<Alamat> list = alamatDao.findAlamatByIdPasien(pelangganId);
			if (!list.isEmpty()) {
				for (Alamat alamat : list) {
					pencucianLinen.setAlamat(alamat.getAlamatLengkap());
				}
			} else {
				pencucianLinen.setAlamat("");
			}
			// add status dan status bayar dan ambil
			getStatusAndStatusBayar(map, noRecStrukPelayanan, pencucianLinen);
			//
			getProdukLinens2(noRecStrukPelayanan, pencucianLinen);
			pencucianLinen.setJumlahCycle(jumlahCycle);
			listDto = pencucianLinen;
		}
		return listDto;
	}

	@Override
	public List<ProsesReturDto> getAllRetur(Date startPeriode, Date endPeriode) {
		List<ProsesReturDto> listDto = new ArrayList<ProsesReturDto>();
		List<Map<String, Object>> listMap = laundryDaoCustom.getAllRetur(startPeriode, endPeriode);
		for (Map<String, Object> map : listMap) {
			ProsesReturDto retur = new ProsesReturDto();
			String noPelanggan = (String) map.get("noPelanggan");
			Integer pelangganId = (Integer) map.get("pelangganId");
			String namaPelanggan = (String) map.get("namaPelanggan");
			String noTelepon = (String) map.get("noTelepon");
			String noRetur = (String) map.get("noRetur");
			retur.setNoPelanggan(noPelanggan);
			retur.setNamaPelanggan(namaPelanggan);
			retur.setNoTelepon(noTelepon);
			retur.setNoRetur(noRetur);
			List<Alamat> list = alamatDao.findAlamatByIdPasien(pelangganId);
			for (Alamat alamat : list) {
				retur.setAlamat(alamat.getAlamatLengkap());
				listDto.add(retur);
			}
		}
		return listDto;
	}

	/*
	 * Order/permintaan laundry Revisi by iwankasan date : 30.01.2017
	 * 
	 */

	@Override
	public Map<String, Object> savePermintaanLaundryExternal(PenerimaanLinenExternalDto dto) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		if(dto.getNoRecStrukPelayanan()!=null){
			strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		}
		strukPelayanan.setNostruk(dto.getNoStruk());
		strukPelayanan.setKdruanganasal(loginUserService.getCurrentRuangan());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		strukPelayanan.setKdruangan(ruangan);
		strukPelayanan.setKeteranganlainnya("Order Laundry External");
		strukPelayanan.setQtyproduk(dto.getBerat());
		strukPelayanan.setTglstruk(dto.getTglOrder());
		Date tglTerima = DateUtil.toDate(dto.getTglTerima());
		strukPelayanan.setTglterimakiriman(tglTerima);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		strukPelayanan.setMenyerahkan(loginUserService.getLoginUser().getPegawai());
		strukPelayanan = this.strukPelayananDao.save(strukPelayanan);
		
		Double totalHargaSatuan = 0.0;
		strukPelayanan.setTotalhargasatuan(totalHargaSatuan);
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			for(ProdukLinenExternalDto itemProduk:dto.getProdukLinens()){
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				Double harga = itemProduk.getHargaSatuan();
				if(itemProduk.getNoRecStrukPelayananDetail()!=null){
					strukPelayananDetail.setNoRec(itemProduk.getNoRecStrukPelayananDetail());
				}
				Produk produk = new Produk();
				produk.setId(itemProduk.getProdukId());
				strukPelayananDetail.setKdproduk(produk);
				strukPelayananDetail.setQtyproduk(itemProduk.getJumlah());
				SatuanStandar satuanStandar = new SatuanStandar();
				satuanStandar.setId(itemProduk.getSatuanId());
				strukPelayananDetail.setKdsatuanstandar(satuanStandar);
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setTglpelayanan(tglTerima);
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail = this.strukPelayananDetailDao.save(strukPelayananDetail);
			}
		}
		
		Map<String, Object> result = new HashMap<>();
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			result.put("noRec", strukPelayanan.getNoRec());
		}
			
		return result;
				
	}
	
	@Override
	public Map<String, Object> savePenerimaanLaundryExternal(PenerimaanLinenExternalDto dto) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		if(dto.getNoRecStrukPelayanan()!=null){
			strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		}
		strukPelayanan.setNostruk(dto.getNoStruk());
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPelayanan.setKdruanganasal(ruanganAsal);
		Ruangan ruangan = ruanganDao.findOne(93); 
		strukPelayanan.setKdruangan(ruangan);
		strukPelayanan.setKeteranganlainnya("Order Laundry External");
		strukPelayanan.setQtyproduk(dto.getBerat());
		strukPelayanan.setTglstruk(dto.getTglOrder());
		Date tglTerima = DateUtil.toDate(dto.getTglTerima());
		strukPelayanan.setTglterimakiriman(tglTerima);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		strukPelayanan.setKdpegawaipenerima(loginUserService.getLoginUser().getPegawai());
		Pegawai pegawaiOrder = new Pegawai();
		pegawaiOrder.setId(dto.getPegawaiOrderId());
		strukPelayanan.setMenyerahkan(pegawaiOrder);
		strukPelayanan = this.strukPelayananDao.save(strukPelayanan);
		
		Double totalHargaSatuan = 0.0;
		strukPelayanan.setTotalhargasatuan(totalHargaSatuan);
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			for(ProdukLinenExternalDto itemProduk:dto.getProdukLinens()){
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				Double harga = itemProduk.getHargaSatuan();
				if(itemProduk.getNoRecStrukPelayananDetail()!=null){
					strukPelayananDetail.setNoRec(itemProduk.getNoRecStrukPelayananDetail());
				}
				Produk produk = new Produk();
				produk.setId(itemProduk.getProdukId());
				strukPelayananDetail.setKdproduk(produk);
				strukPelayananDetail.setQtyproduk(itemProduk.getJumlah());
				SatuanStandar satuanStandar = new SatuanStandar();
				satuanStandar.setId(itemProduk.getSatuanId());
				strukPelayananDetail.setKdsatuanstandar(satuanStandar);
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setTglpelayanan(tglTerima);
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail = this.strukPelayananDetailDao.save(strukPelayananDetail);
			}
		}
		
		Map<String, Object> result = new HashMap<>();
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			result.put("noRec", strukPelayanan.getNoRec());
		}
			
		return result;
				
	}

	//Pengambilan Linen Kotor, 
	//sesuai dengan hasil meeting dng laundry
	//tgl.17.05.2018
	@Override
	public Map<String, Object> savePengambilanLaundryInternal(PenerimaanLinenExternalDto dto) {
		Map<String, Object> result = new HashMap<>();
		
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setNostruk(dto.getNoStruk());
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPelayanan.setKdruanganasal(ruanganAsal);
		Ruangan ruangan = ruanganDao.findOne(93); 
		strukPelayanan.setKdruangan(ruangan);
		//flag untuk pengambilan linen kotor
		strukPelayanan.setKeteranganlainnya("Pengambilan Linen Kotor Internal");
		strukPelayanan.setQtyproduk(dto.getBerat());
		strukPelayanan.setTglstruk(dto.getTglOrder());
		Date tglTerima = DateUtil.toDate(dto.getTglTerima());
		//strukPelayanan.setTglterimakiriman(tglTerima);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		strukPelayanan.setKdpegawaipenerima(loginUserService.getLoginUser().getPegawai());
		Pegawai pegawaiOrder = new Pegawai();
		pegawaiOrder.setId(dto.getPegawaiOrderId());
		strukPelayanan.setMenyerahkan(pegawaiOrder);
		StrukPelayanan strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
		
		if(CommonUtil.isNotNullOrEmpty(strukPelayananResult.getNoRec())){
			result.put("noRec", strukPelayananResult.noRec);
			
		}
		
		return result;
	}

	
	/*
	 * Penerimaan laundry Revisi by iwankasan date : 30.01.2017
	 * 
	 */
	//sesuai dengan hasil review penerimaanlaundryinternal menjadi=Pengambilan Linen Kotor
	//date 04.05.2018
	//diubah lagi : menjadi permintaan linen bersih dari ruangan
	//sesuai dengan hasil meeting dengan laundry 17.05.2018
	@Override
	public Map<String, Object> savePenerimaanLaundryInternal(PenerimaanLinenExternalDto dto) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		if(dto.getNoRecStrukPelayanan()!=null){
			strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		}
		strukPelayanan.setNostruk(dto.getNoStruk());
		Ruangan ruanganAsal = new Ruangan();
		ruanganAsal.setId(dto.getRuanganAsalId());
		strukPelayanan.setKdruanganasal(ruanganAsal);
		Ruangan ruangan = ruanganDao.findOne(93); 
		strukPelayanan.setKdruangan(ruangan);
		//flag untuk pengambilan linen kotor
		strukPelayanan.setKeteranganlainnya("Order Laundry Internal");
		strukPelayanan.setQtyproduk(dto.getBerat());
		strukPelayanan.setTglstruk(dto.getTglOrder());
		Date tglTerima = DateUtil.toDate(dto.getTglTerima());
		//strukPelayanan.setTglterimakiriman(tglTerima);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		strukPelayanan.setKdpegawaipenerima(loginUserService.getLoginUser().getPegawai());
		Pegawai pegawaiOrder = new Pegawai();
		pegawaiOrder.setId(dto.getPegawaiOrderId());
		strukPelayanan.setMenyerahkan(pegawaiOrder);
		strukPelayanan = this.strukPelayananDao.save(strukPelayanan);
		
		Double totalHargaSatuan = 0.0;
		strukPelayanan.setTotalhargasatuan(totalHargaSatuan);
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			for(ProdukLinenExternalDto itemProduk:dto.getProdukLinens()){
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				Double harga = itemProduk.getHargaSatuan();
				if(itemProduk.getNoRecStrukPelayananDetail()!=null){
					strukPelayananDetail.setNoRec(itemProduk.getNoRecStrukPelayananDetail());
				}
				Produk produk = new Produk();
				produk.setId(itemProduk.getProdukId());
				strukPelayananDetail.setKdproduk(produk);
				strukPelayananDetail.setQtyproduk(itemProduk.getJumlah());
				SatuanStandar satuanStandar = new SatuanStandar();
				satuanStandar.setId(itemProduk.getSatuanId());
				strukPelayananDetail.setKdsatuanstandar(satuanStandar);
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setTglpelayanan(dto.getTglOrder());
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail = this.strukPelayananDetailDao.save(strukPelayananDetail);
			}
		}
		
		Map<String, Object> result = new HashMap<>();
		if(CommonUtil.isNotNullOrEmpty(strukPelayanan)) {
			result.put("noRec", strukPelayanan.getNoRec());
		}
			
		return result;
				
	}

	//digunakan untuk getData Pengambilan Linen Kotor dari Ruangan
	//sesuai dengan review dengan team Laundry
	//date : 11.05.2018
	//dikembalikan lagi menjadi permintaan laundry dari ruangan
	//hasil meeting dengan team laundry (ibu merlin, dkk)
	//date : 17.05.2018
	//date : 23.11.2018
	//menampilkan data dari ruangan masing-masing
	@Override
	public Map<String, Object> getOrderLaundrySebelumDiTerima(String startDate, String endDate) {
		Map<String, Object> data = new HashMap<>();
		//Ruangan ruanganAsal = new Ruangan();
		//ruanganAsal.setId(loginUserService.getCurrentRuangan().getId());
		//Integer ruanganAsalId = loginUserService.getCurrentRuangan().getId();
		data.put("data", this.laundryDao.getOrderLaundrySebelumDiTerima(startDate, endDate));
		return data;
	}

	//digunakan untuk getData Pengambilan Linen Kotor dari Ruangan by noRec
	//sesuai dengan review dengan team Laundry
	//date : 11.05.2018
	//dikembalikan lagi menjadi permintaan laundry dari ruangan
	//hasil meeting dengan team laundry (ibu merlin, dkk)
	//date : 17.05.2018
	@Override
	public Map<String, Object> getOrderLaundrySebelumDiTerimaDetail(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
		
		result.put("header", this.laundryDao.getOrderLaundrySebelumDiTerimaByNoOrder(noRec));
		//data.put("detail", this.laundryDao.getDetailOrderLaundryByOrder(noRec));
		List<Map<String, Object>> detail = this.laundryDao.getDetailOrderLaundryByOrder(noRec);
		for(Map<String, Object> item:detail) {
			item.put("stock", this.laundryDao.getCekStockLinenBersih((Integer)item.get("idProduk")));
			data.add(item);
		}
		result.put("item", data);
		
		return result;
	}
	
	
	

	@Override
	public Map<String, Object> getMonitoringPermintaanLaundryDariRuangan(String startDate, String endDate) {
		Map<String, Object> data = new HashMap<>();
		data.put("data", this.laundryDao.getMonitoringPermintaanLaundryDariRuangan(startDate, endDate));
		return data;
	}

	@Override
	public Map<String, Object> getMonitoringPermintaanLaundryDariRuanganDetail(String noRec) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getDetailOrderLaundryByOrder(noRec));
		return result;
	}

	@Override
	public Map<String, Object> getOrderLaundryDiterima() {
		Map<String, Object> data = new HashMap<>();
		data.put("data", this.laundryDao.getOrderLaundryDiTerima());
		return data;
	}

	@Override
	public Map<String, Object> getOrderLaundryDiterimaDetail(String noRec) {
		Map<String, Object> data = new HashMap<>();
		data.put("header", this.laundryDao.getOrderLaundryDiTerimaByNoOrder(noRec));
		data.put("detail", this.laundryDao.getDetailOrderLaundryByOrder(noRec));
		return data;
	}

	//proses cuci internal
	//create by iwankasan
	//date : 05.02.2018
	@Override
	public Map<String, Object> saveProsesPencucianInternal(ProsesCuciLinenDto dto) {
		//create StrukPelayanan
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		
		Date tanggal = DateUtil.toDate(dto.getTglPencucianLinen());
		Date tanggalAkhir = DateUtil.toDate(dto.getTglSelesaiPencucianLinen());
		
		if(dto.getNoRecStrukPelayanan()!=null){
			strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		}
		//String noStruk = noUrut("StrukPelayanan"); //"StrukPelayanan"
		String noStruk = strukOrderService.formatNoUrut("StrukPelayanan", "PCI");
		strukPelayanan.setNostruk(noStruk);
		strukPelayanan.setKdruanganasal(loginUserService.getCurrentRuangan());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		strukPelayanan.setKdruangan(ruangan);
		strukPelayanan.setKeteranganlainnya("Proses Pencucian Internal");
		strukPelayanan.setQtyproduk(dto.getBeratLinen());
		strukPelayanan.setTglstruk(tanggal);
		strukPelayanan.setTglterimakiriman(tanggal);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		//strukPelayanan.setMenyerahkan(loginUserService.getLoginUser().getPegawai());
		strukPelayanan = this.strukPelayananDao.save(strukPelayanan);
		
		StrukPlanning strukPlanning = new StrukPlanning();
		Ruangan ruanganAsalId = ruanganDao.findOne(dto.getRuanganAsalId());
		strukPlanning.setKdruanganasal(ruanganAsalId);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setTglplanning(tanggal);
		strukPlanning.setKeteranganlainnya("Proses Pencucian Internal");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
	
		//save planning pelayanan
		savePlanningPelayanan(dto, strukPlanning, tanggal, tanggalAkhir, ruangan, strukPelayanan);	
		
		//save bahan yang terpakai
		savePlanningPelayananDbhp(dto, strukPlanning, tanggal);
		
		PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
		Pegawai pegawai = new Pegawai();
		pegawai.setId(dto.getPetugasId());
		planningPelayananPetugas.setPegawai(pegawai);
		planningPelayananPetugas.setPegawaiExec(pegawai);
		planningPelayananPetugas.setStrukPlaning(strukPlanning);
		planningPelayananPetugas.setTglPlanning(tanggal);
		planningPelayananPetugas.setRuangan(ruangan);
		planningPelayananPetugas.setTglPelayanan(tanggal);
		planningPelayananPetugas.setIsPetugasPepJawab((byte) 1);
		planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		
		Map<String, Object> result = new HashMap<>();
		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
			result.put("noRecStrukPelayanan", strukPelayanan.getNoRec());
		}
		
		//update stock bahan here
		return result;
	}
	
	private void savePlanningPelayanan(ProsesCuciLinenDto dto, StrukPlanning strukPlanning, 
			Date tanggal, Date tanggalAkhir, Ruangan ruangan, StrukPelayanan strukPelayanan){
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)){
			planningPelayanan.setStrukPlaning(strukPlanning);
			planningPelayanan.setStrukPelayanan(strukPelayanan);
			planningPelayanan.setTglPlanning(tanggal);
			planningPelayanan.setTglPelayanan(tanggal);
			planningPelayanan.setTglPlanningAkhir(tanggalAkhir);
			planningPelayanan.setRuangan(ruangan);
			planningPelayanan.setQtyProdukExec(dto.getBeratLinen());
			planningPelayanan.setTglPlanningExecAwal(tanggal);
			planningPelayanan.setTglPlanningExecAkhir(tanggalAkhir);
			Alat alat = this.alatDao.findOne(dto.getMesinId());
			planningPelayanan.setProduk(alat.getProdukAset());
			planningPelayanan.setQtyProdukRetur(0.0);
			planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
			
		}
		
	}
	
	private void savePlanningPelayananDbhp(ProsesCuciLinenDto dto, StrukPlanning strukPlanning, Date tanggal) {
		List<PlanningPelayananDbhp> listPlanningPelayananDbhp = new ArrayList<PlanningPelayananDbhp>();
		for(KapasitasBahanMesinDto kapasitasBahanMesinDto:dto.getKapasitasBahanMesins()){
			PlanningPelayananDbhp planningPelayananDbhp = new PlanningPelayananDbhp();
			Produk produkBahan = this.produkDao.findOne(kapasitasBahanMesinDto.getProdukBahanId());
			planningPelayananDbhp.setStrukPlanning(strukPlanning);
			planningPelayananDbhp.setProduk(produkBahan);
			planningPelayananDbhp.setQtyProduk(kapasitasBahanMesinDto.getJumlahBahan());
			SatuanStandar satuan = this.satuanStandarDao.findOne(kapasitasBahanMesinDto.getSatuanBahanId());
			planningPelayananDbhp.setSatuanStandar(satuan);
			planningPelayananDbhp.setTanggalPlanning(tanggal);
			planningPelayananDbhp.setKeterangan(kapasitasBahanMesinDto.getBilas());
			listPlanningPelayananDbhp.add(planningPelayananDbhp);
			
			//update by iwankasan
			//03.10.2018
			//stock bahan dikurangi pemakaian
			//update stok global bahan yg digunakan
			//09.10.2018
			//ada perbaikan dari bro nanda, agar update stok menggunakan stokprodukdetail_t
			System.out.println("---Start Update Stock Produk Detail---");
			Ruangan ruanganAsal = this.ruanganDao.findById(93); //ruang laundry
			Integer ruanganAsalStock = ruanganAsal.getId(); //ruang laundry
			//StokProdukGlobal stokProdukGlobal = this.stokProdukGlobalDao.findbyProdukAndRuangan(produkBahan.getId(),ruanganAsalStock);
			StokProdukDetail stokProdukGlobal = this.stokProdukDetailDao.findbyProdukAndRuangan(produkBahan.getId(),ruanganAsalStock);
			StokProdukDetail resultGlobal = null;
			if(stokProdukGlobal != null) {
				Double qtyProduk = stokProdukGlobal.getQtyProduk();
				Double jumlah = qtyProduk - Double.parseDouble(String.valueOf(kapasitasBahanMesinDto.getJumlahBahan()));
				stokProdukGlobal.setQtyProduk(jumlah);
				resultGlobal = this.stokProdukDetailDao.save(stokProdukGlobal);
			}
			
			//update by iwankasan
			//03.10.2018
			//update kartustok bahan yg digunakan
			System.out.println("---Start update Kartu Stock---");
			Double jml = Double.parseDouble(String.valueOf(kapasitasBahanMesinDto.getJumlahBahan()));
			String keterangan = "pemakaian bahan pencucian linen";
			Boolean status = false;
			Produk produkstock =  this.produkDao.findById(produkBahan.getId());
			this.kartuStokService.saveKartuStok(jml, produkstock, ruanganAsal, keterangan, status, tanggal);
			
			
		}
		Iterable<PlanningPelayananDbhp> planningPelayananDbhpResult = this.planningPelayananDbhpDao.save(listPlanningPelayananDbhp);
		
	}

	@Override
	public Map<String, Object> getProsesCucianInternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
		
		List<Map<String, Object>> listStrukPlanning = this.laundryDao.getProsesCuciInternal(startDate, endDate);
		for(Map<String, Object>listpetugas:listStrukPlanning){
			listpetugas.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)listpetugas.get("noRec")));
			data.add(listpetugas);

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

	@Override
	public Map<String, Object> getProsesCuciianInternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
		
		List<Map<String, Object>> listdata = this.laundryDao.getProsesCuciInternalbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));
			
			List<Map<String, Object>> listbilas = this.laundryDao.getProsesCuciInternalBilasByNoRec((String)item.get("noRec"));
			for(Map<String, Object>itembilas:listbilas){
				itembilas.put("bahan", this.laundryDao.getProsesCuciInternalBahanByNoRecBilas((String)item.get("noRec"), (String)itembilas.get("bilas")));
				data.add(itembilas);
			}
			
			data.add(item);
			
		}
		result.put("data", data);
		return result;
	}

	//iwan kasan 
	//date : 08.02.2018
	@Override
	public Map<String, Object> savePengeringanInternal(PengeringanDto dto) {
		Map<String, Object> result = new HashMap<>();
		StrukPlanning strukPlanning = new StrukPlanning();
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
	

		Ruangan ruangan = ruanganDao.findOne(93); //ruanga Pengeringan
		KelompokTransaksi kelompokTransaksi = kelompokTransaksiDao.findOne(74); //transaksi pengeringan
		Produk produk = produkDao.findOne(10013083);

		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruangan);
		strukPlanning.setTglplanning(tgl);
		strukPlanning.setKeteranganlainnya("Proses Pengeringan Internal");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
		
		//set planning pelayanan
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)) {
			savePlanningPelayananPengeringan(dto, dto.getJumlahCycle(), strukPlanning, tgl, tglKerja, ruangan, dto.getNoRecStrukPelayanan(), produk);
		}
		
		//set petugas
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)) {
			PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			planningPelayananPetugas.setPegawai(pegawai);
			planningPelayananPetugas.setPegawaiExec(pegawai);
			planningPelayananPetugas.setStrukPlaning(strukPlanning);
			planningPelayananPetugas.setTglPlanning(tgl);
			planningPelayananPetugas.setRuangan(ruangan);
			planningPelayananPetugas.setTglPelayanan(tgl);
			planningPelayananPetugas.setIsPetugasPepJawab((byte) 1);
			planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		}
		
		//update status Proses Pencucian menjadi Proses Pencucian sdh Pengeringan
		//StrukPelayanan strukPelayananUpdate = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		//strukPelayananUpdate.setKeteranganlainnya("Proses Pencucian Internal sdh Pengeringan");
		//strukPelayananUpdate = this.strukPelayananDao.save(strukPelayananUpdate);
		

		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
		}
		
		return result;
	}
	
	//iwan kasan 
	//date : 08.02.2018
	@Override
	public Map<String, Object> savePengeringanExternal(PengeringanDto dto) {
			Map<String, Object> result = new HashMap<>();
			StrukPlanning strukPlanning = new StrukPlanning();
			Date tgl = DateUtil.toDate(dto.getTgl());
			Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		

			Ruangan ruangan = ruanganDao.findOne(93); //ruanga Pengeringan
			KelompokTransaksi kelompokTransaksi = kelompokTransaksiDao.findOne(74); //transaksi pengeringan
			Produk produk = produkDao.findOne(10013083);

			strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
			strukPlanning.setKdruangan(ruangan);
			strukPlanning.setKdruanganasal(ruangan);
			strukPlanning.setTglplanning(tgl);
			strukPlanning.setKeteranganlainnya("Proses Pengeringan External");
			StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
			
			//set planning pelayanan
			if(CommonUtil.isNotNullOrEmpty(strukPlanning)) {
				savePlanningPelayananPengeringan(dto, dto.getJumlahCycle(), strukPlanning, tgl, tglKerja, ruangan, dto.getNoRecStrukPelayanan(), produk);
			}
			
			//set petugas
			if(CommonUtil.isNotNullOrEmpty(strukPlanning)) {
				PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
				Pegawai pegawai = new Pegawai();
				pegawai.setId(dto.getPetugasId());
				planningPelayananPetugas.setPegawai(pegawai);
				planningPelayananPetugas.setPegawaiExec(pegawai);
				planningPelayananPetugas.setStrukPlaning(strukPlanning);
				planningPelayananPetugas.setTglPlanning(tgl);
				planningPelayananPetugas.setRuangan(ruangan);
				planningPelayananPetugas.setTglPelayanan(tgl);
				planningPelayananPetugas.setIsPetugasPepJawab((byte) 1);
				planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
			}
			
			//update status Proses Pencucian menjadi Proses Pencucian sdh Pengeringan
			//StrukPelayanan strukPelayananUpdate = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
			//strukPelayananUpdate.setKeteranganlainnya("Proses Pencucian External sdh Pengeringan");
			//strukPelayananUpdate = this.strukPelayananDao.save(strukPelayananUpdate);

			if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
				result.put("noRec", strukPlanningResult.getNoRec());
			}
			
			return result;
		}

	
	private void savePlanningPelayananPengeringan(PengeringanDto dto, Integer jumlahCycle, StrukPlanning strukPlanning, 
			Date tanggal, Date tanggalAkhir, Ruangan ruangan, String noRecStrukPelayanan, Produk produk){
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		
			planningPelayanan.setStrukPlaning(strukPlanning);
			
			StrukPelayanan strukPelayanan = new StrukPelayanan();
			strukPelayanan.setNoRec(noRecStrukPelayanan);
			planningPelayanan.setStrukPelayanan(strukPelayanan);
			
			planningPelayanan.setTglPlanning(tanggal);
			planningPelayanan.setTglPelayanan(tanggal);
			planningPelayanan.setTglPlanningAkhir(tanggalAkhir);
			planningPelayanan.setRuangan(ruangan);
			planningPelayanan.setQtyProdukExec(dto.getBeratLinen());
			planningPelayanan.setTglPlanningExecAwal(tanggal);
			planningPelayanan.setTglPlanningExecAkhir(tanggalAkhir);
			Alat alat = this.alatDao.findOne(dto.getMesinId());
			planningPelayanan.setProduk(alat.getProdukAset());
			planningPelayanan.setQtyProdukRetur(0.0);
			planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
			
			if(CommonUtil.isNotNullOrEmpty(planningPelayanan)){
				PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
				planningPelayananDetail.setPlanningPelayanan(planningPelayanan);
				planningPelayananDetail.setStrukPelayanan(strukPelayanan);
				planningPelayananDetail.setRuangan(ruangan);
				planningPelayananDetail.setAlat(alat);
				planningPelayananDetail.setProduk(alat.getProdukAset()); 
				planningPelayananDetail.setProdukDetail(produk);
				planningPelayananDetail.setQtyProdukDetail(dto.getBeratLinen());
				planningPelayananDetail.setTglPlanning(tanggal);
				planningPelayananDetail.setTotalVolumeProdukDetail(dto.getBeratLinen());
				planningPelayananDetail.setJumlahCycle(jumlahCycle);
				planningPelayananDetail = this.planningPelayananDetailDao.save(planningPelayananDetail);
			}
					
	}

	@Override
	public Map<String, Object> getProsesPengeringanInternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data", this.laundryDao.getProsesPengeringanInternal(startDate, endDate));
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesPengeringanExternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data", this.laundryDao.getProsesPengeringanExternal(startDate, endDate));
		return result;
	}

	@Override
	public Map<String, Object> getProsesPengeringanInternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPengeringanInternalbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesPengeringanExternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPengeringanInternalbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> savePelipatanInternal(PelipatanDto dto) {
		Map<String, Object> result = new HashMap<>();
		
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		Produk produk = this.produkDao.findOne(10013084);
		
		//set strukpelayanan
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		String noStruk = strukOrderService.formatNoUrut("StrukPelayanan", "PPL");
		strukPelayanan.setNostruk(noStruk);
		strukPelayanan.setKdruanganasal(loginUserService.getCurrentRuangan());
		
		strukPelayanan.setKdruangan(ruangan);
		strukPelayanan.setKeteranganlainnya("Proses Pelipatan");
		strukPelayanan.setQtyproduk(0.0);
		strukPelayanan.setTglstruk(tgl);
		KelompokTransaksi kelompokTransaksi = this.kelompokTransaksiDao.findById(75); //set kelompok transaksi pelipatan 
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		StrukPelayanan strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
		
		//set strukplanning
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruangan);
		strukPlanning.setTglplanning(tgl);
		strukPlanning.setKeteranganlainnya("Proses Pelipatan");
		strukPlanning = this.strukPlanningDao.save(strukPlanning);
		
		//set Planning Pelayanan
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		planningPelayanan.setStrukPelayanan(strukPelayanan);
		planningPelayanan.setStrukPlaning(strukPlanning);
		planningPelayanan.setTglPelayanan(tgl);
		planningPelayanan.setTglPlanning(tgl);
		planningPelayanan.setTglPlanningAkhir(tgl);
		planningPelayanan.setTglPlanningExecAwal(tgl);
		planningPelayanan.setTglPlanningExecAkhir(tglKerja);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		planningPelayanan.setQtyProdukExec(0.0);
		planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
		if(CommonUtil.isNotNullOrEmpty(planningPelayanan)) {
			for(PelipatanProdukDetailDto pelipatanDetailDto : dto.getProdukDetails()) {
				PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
				planningPelayananDetail.setPlanningPelayanan(planningPelayanan);
				planningPelayananDetail.setStrukPelayanan(strukPelayanan);
				planningPelayananDetail.setTglPlanning(tgl);
				planningPelayananDetail.setRuangan(ruangan);
				Alat alat = new Alat();
				alat.setId(3); //set alat tdk boleh null, maka difixed-kan, ini bisa berubah
				planningPelayananDetail.setAlat(alat);
				planningPelayananDetail.setProduk(produk);
				Produk produkLinen = this.produkDao.findOne(pelipatanDetailDto.getProdukDetailId());
				planningPelayananDetail.setProdukDetail(produkLinen);
				
				Double beratLinen = pelipatanDetailDto.getBeratLinen();
				Integer jumlahLipatan = pelipatanDetailDto.getJumlahLipat();
				Double totalBerat = beratLinen*jumlahLipatan;
				planningPelayananDetail.setJumlahCycle(jumlahLipatan);
				planningPelayananDetail.setQtyProdukDetail(beratLinen);
				planningPelayananDetail.setTotalVolumeProdukDetail(totalBerat);
				planningPelayananDetail = this.planningPelayananDetailDao.save(planningPelayananDetail);
				
				//hasil permintaan dari ibu marlin (laundry)
				//date : 07.11.2018, agar stok sdh diupdate pd saat pelipatan
				//krn tdk semua linen harus melalui roll
				
				//---UPDATE STOCK----
				//update stok detail
				Integer produkDetail = pelipatanDetailDto.getProdukDetailId();
				System.out.println("---Start Update Stock Detail---");
				StokProdukDetail stokProdukDetail = this.stokProdukDetailDao.findbyProdukAndRuangan(produkDetail, ruangan.getId());
				StokProdukDetail resultDetail = null;
				if(stokProdukDetail != null) {
					Double qtyProduk = stokProdukDetail.getQtyProduk();
					Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(String.valueOf(pelipatanDetailDto.getJumlahLipat())));
					stokProdukDetail.setQtyProduk(jumlah);
					resultDetail = this.stokProdukDetailDao.save(stokProdukDetail);
				}
					
				//update kartustok
				System.out.println("---Start update Kartu Stock---");
				Double jml = Double.parseDouble(String.valueOf(pelipatanDetailDto.getJumlahLipat()));
				String keterangan = "pelipatan laundry";
				Boolean status = true;
				Produk produkstock =  this.produkDao.findById(produkDetail);
				this.kartuStokService.saveKartuStok(jml, produkstock, ruangan, keterangan, status, tgl);
				
				
			}
		}
		//set petugas pelaksana
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)){
			PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			planningPelayananPetugas.setPegawai(pegawai);
			planningPelayananPetugas.setPegawaiExec(pegawai);
			planningPelayananPetugas.setStrukPlaning(strukPlanning);
			planningPelayananPetugas.setTglPlanning(tgl);
			planningPelayananPetugas.setTglPelayanan(tgl);
			planningPelayananPetugas.setIsPetugasPepJawab((byte)1);
			planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		}
		
		//set flag untuk 
		//update status Proses Pencucian menjadi Proses Pencucian sdh Pengeringan
		//StrukPelayanan strukPelayananUpdate = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		//strukPelayananUpdate.setKeteranganlainnya("Proses Pengeringan Internal sdh Pelipatan");
		//strukPelayananUpdate = this.strukPelayananDao.save(strukPelayananUpdate);
		
		if(CommonUtil.isNotNullOrEmpty(strukPelayananResult)){
			result.put("noRec", strukPelayananResult.getNoRec());
		}
		return result;
	}
	
	@Override
	public Map<String, Object> savePelipatanExternal(PelipatanDto dto) {
		Map<String, Object> result = new HashMap<>();
		
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		Produk produk = this.produkDao.findOne(10013084);
		
		//set strukpelayanan
		//StrukPelayanan strukPelayanan = new StrukPelayanan();
		//String noStruk = strukOrderService.formatNoUrut("StrukPelayanan", "PPL");
		//strukPelayanan.setNostruk(noStruk);
		//strukPelayanan.setKdruanganasal(loginUserService.getCurrentRuangan());
		
		//strukPelayanan.setKdruangan(ruangan);
		//strukPelayanan.setKeteranganlainnya("Proses Pelipatan");
		//strukPelayanan.setQtyproduk(0.0);
		//strukPelayanan.setTglstruk(tgl);
		KelompokTransaksi kelompokTransaksi = this.kelompokTransaksiDao.findById(75); //set kelompok transaksi pelipatan 
		//strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		//trukPelayanan strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
		
		//set strukplanning
		StrukPlanning strukPlanning = new StrukPlanning();
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruangan);
		strukPlanning.setTglplanning(tgl);
		strukPlanning.setKeteranganlainnya("Proses Pelipatan External");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
		
		//set Planning Pelayanan
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		//planningPelayanan.setStrukPelayanan(strukPelayanan);
		StrukPelayanan strukPelayanan = this.strukPelayananDao.findByNoRec(dto.getNoRecStrukPelayanan());
		planningPelayanan.setStrukPelayanan(strukPelayanan);
		planningPelayanan.setStrukPlaning(strukPlanning);
		planningPelayanan.setTglPelayanan(tgl);
		planningPelayanan.setTglPlanning(tgl);
		planningPelayanan.setTglPlanningAkhir(tgl);
		planningPelayanan.setTglPlanningExecAwal(tgl);
		planningPelayanan.setTglPlanningExecAkhir(tglKerja);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		planningPelayanan.setQtyProdukExec(0.0);
		planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
		if(CommonUtil.isNotNullOrEmpty(planningPelayanan)) {
			for(PelipatanProdukDetailDto pelipatanDetailDto : dto.getProdukDetails()) {
				PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
				planningPelayananDetail.setPlanningPelayanan(planningPelayanan);
				planningPelayananDetail.setStrukPelayanan(strukPelayanan);
				planningPelayananDetail.setTglPlanning(tgl);
				planningPelayananDetail.setRuangan(ruangan);
				Alat alat = new Alat();
				alat.setId(3); //set alat, ini bisa berubah.....
				planningPelayananDetail.setAlat(alat);
				planningPelayananDetail.setProduk(produk);
				Produk produkLinen = this.produkDao.findOne(pelipatanDetailDto.getProdukDetailId());
				planningPelayananDetail.setProdukDetail(produkLinen);
				
				Double beratLinen = pelipatanDetailDto.getBeratLinen();
				Integer jumlahLipatan = pelipatanDetailDto.getJumlahLipat();
				Double totalBerat = beratLinen*jumlahLipatan;
				planningPelayananDetail.setJumlahCycle(jumlahLipatan);
				planningPelayananDetail.setQtyProdukDetail(beratLinen);
				planningPelayananDetail.setTotalVolumeProdukDetail(totalBerat);
				planningPelayananDetail = this.planningPelayananDetailDao.save(planningPelayananDetail);
				
			}
		}
		//set petugas pelaksana
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)){
			PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			planningPelayananPetugas.setPegawai(pegawai);
			planningPelayananPetugas.setPegawaiExec(pegawai);
			planningPelayananPetugas.setStrukPlaning(strukPlanning);
			planningPelayananPetugas.setTglPlanning(tgl);
			planningPelayananPetugas.setTglPelayanan(tgl);
			planningPelayananPetugas.setIsPetugasPepJawab((byte)1);
			planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		}
	
		//set flag untuk 
		//update status Proses Pencucian menjadi Proses Pencucian sdh Pengeringan
		StrukPelayanan strukPelayananUpdate = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		strukPelayananUpdate.setKeteranganlainnya("Proses Pengeringan External sdh Pelipatan");
		strukPelayananUpdate = this.strukPelayananDao.save(strukPelayananUpdate);

		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
		}
		return result;
	}


	@Override
	public Map<String, Object> getProsesPelipatan(String startDate, String endDate) {
		
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPelipatan(startDate, endDate);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesPelipatanExternal(String startDate, String endDate) {
		
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPelipatanExternal(startDate, endDate);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> getProsesPelipatanByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
						
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPelipatanbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("detail", this.laundryDao.getProsesPelipatanDetailbyNoRec((String)item.get("noRec")));
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesPelipatanExternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
						
		List<Map<String, Object>> listdata = this.laundryDao.getProsesPelipatanExternalbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("detail", this.laundryDao.getProsesPelipatanDetailbyNoRec((String)item.get("noRec")));
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> saveRollPressInternal(PelipatanDto dto) {

		Map<String, Object> result = new HashMap<>();
				
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		Produk produk = this.produkDao.findOne(10013084);
	
		//set strukplanning
		StrukPlanning strukPlanning = new StrukPlanning();
		KelompokTransaksi kelompokTransaksi = this.kelompokTransaksiDao.findById(75); //set kelompok transaksi pelipatan, blm ada kelompk transaksi roll
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruangan);
		strukPlanning.setTglplanning(tgl);
		strukPlanning.setKeteranganlainnya("Proses Roll Press");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
				
		//set Planning Pelayanan
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		StrukPelayanan strukPelayanan = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		planningPelayanan.setStrukPelayanan(strukPelayanan);
		planningPelayanan.setStrukPlaning(strukPlanning);
		planningPelayanan.setTglPelayanan(tgl);
		planningPelayanan.setTglPlanning(tgl);
		planningPelayanan.setTglPlanningAkhir(tgl);
		planningPelayanan.setTglPlanningExecAwal(tgl);
		planningPelayanan.setTglPlanningExecAkhir(tglKerja);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		planningPelayanan.setQtyProdukExec(0.0);
		planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
		if(CommonUtil.isNotNullOrEmpty(planningPelayanan)) {
			for(PelipatanProdukDetailDto pelipatanDetailDto : dto.getProdukDetails()) {
				PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
				planningPelayananDetail.setPlanningPelayanan(planningPelayanan);
				planningPelayananDetail.setStrukPelayanan(strukPelayanan);
				planningPelayananDetail.setTglPlanning(tgl);
				planningPelayananDetail.setRuangan(ruangan);
				Alat alat = new Alat();
				alat.setId(3); //set alat, ini bisa berubah.....
				planningPelayananDetail.setAlat(alat);
				planningPelayananDetail.setProduk(produk);
				Produk produkLinen = this.produkDao.findOne(pelipatanDetailDto.getProdukDetailId());
				planningPelayananDetail.setProdukDetail(produkLinen);
						
				Double beratLinen = pelipatanDetailDto.getBeratLinen();
				Integer jumlahLipatan = pelipatanDetailDto.getJumlahLipat();
				Double totalBerat = beratLinen*jumlahLipatan;
				planningPelayananDetail.setJumlahCycle(jumlahLipatan);
				planningPelayananDetail.setQtyProdukDetail(beratLinen);
				planningPelayananDetail.setTotalVolumeProdukDetail(totalBerat);
				planningPelayananDetail = this.planningPelayananDetailDao.save(planningPelayananDetail);
				
				//dipindahkan ke proses peliatan
				//sesuai dengan permintaan dari laundry
				//---UPDATE STOCK----
				//update stok detail
				//Integer produkDetail = pelipatanDetailDto.getProdukDetailId();
				//System.out.println("---Start Update Stock Detail---");
				//StokProdukDetail stokProdukDetail = this.stokProdukDetailDao.findbyProdukAndRuangan(produkDetail, ruangan.getId());
				//StokProdukDetail resultDetail = null;
				//if(stokProdukDetail != null) {
				//	Double qtyProduk = stokProdukDetail.getQtyProduk();
				//	Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(String.valueOf(pelipatanDetailDto.getJumlahLipat())));
				//	stokProdukDetail.setQtyProduk(jumlah);
				//	resultDetail = this.stokProdukDetailDao.save(stokProdukDetail);
				//}
				
				//update kartustok
				//System.out.println("---Start update Kartu Stock---");
				//Double jml = Double.parseDouble(String.valueOf(pelipatanDetailDto.getJumlahLipat()));
				//String keterangan = "roll press laundry";
				//Boolean status = true;
				//Produk produkstock =  this.produkDao.findById(produkDetail);
				//this.kartuStokService.saveKartuStok(jml, produkstock, ruangan, keterangan, status, tgl);

			}
	
		}
		
		//set petugas pelaksana
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)){
			PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			planningPelayananPetugas.setPegawai(pegawai);
			planningPelayananPetugas.setPegawaiExec(pegawai);
			planningPelayananPetugas.setStrukPlaning(strukPlanning);
			planningPelayananPetugas.setTglPlanning(tgl);
			planningPelayananPetugas.setTglPelayanan(tgl);
			planningPelayananPetugas.setIsPetugasPepJawab((byte)1);
			planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		}
		
		//set flag untuk pelipatan setelah dilakukannya roll
		//flanya ditampung di keteranganAmbil
		StrukPelayanan strukPelayananPelipatan = this.strukPelayananDao.findByNoRec(dto.getNoRecStrukPelayanan());
		strukPelayananPelipatan.setKeteranganAmbil("Proses Pelipatan");
		strukPelayananPelipatan = this.strukPelayananDao.save(strukPelayananPelipatan);

		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
		}
		return result;

	}
	
	@Override
	public Map<String, Object> saveRollPressExternal(PelipatanDto dto) {

		Map<String, Object> result = new HashMap<>();
				
		Date tgl = DateUtil.toDate(dto.getTgl());
		Date tglKerja = DateUtil.toDate(dto.getTglKerja());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		Produk produk = this.produkDao.findOne(10013084);
	
		//set strukplanning
		StrukPlanning strukPlanning = new StrukPlanning();
		KelompokTransaksi kelompokTransaksi = this.kelompokTransaksiDao.findById(75); //set kelompok transaksi pelipatan, blm ada kelompk transaksi roll
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdruanganasal(ruangan);
		strukPlanning.setTglplanning(tgl);
		strukPlanning.setKeteranganlainnya("Proses Roll Press External");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
				
		//set Planning Pelayanan
		PlanningPelayanan planningPelayanan = new PlanningPelayanan();
		StrukPelayanan strukPelayanan = this.strukPelayananDao.findOne(dto.getNoRecStrukPelayanan());
		planningPelayanan.setStrukPelayanan(strukPelayanan);
		planningPelayanan.setStrukPlaning(strukPlanning);
		planningPelayanan.setTglPelayanan(tgl);
		planningPelayanan.setTglPlanning(tgl);
		planningPelayanan.setTglPlanningAkhir(tgl);
		planningPelayanan.setTglPlanningExecAwal(tgl);
		planningPelayanan.setTglPlanningExecAkhir(tglKerja);
		planningPelayanan.setRuangan(ruangan);
		planningPelayanan.setProduk(produk);
		planningPelayanan.setQtyProdukRetur(0.0);
		planningPelayanan.setQtyProdukExec(0.0);
		planningPelayanan = this.planningPelayananDao.save(planningPelayanan);
		if(CommonUtil.isNotNullOrEmpty(planningPelayanan)) {
			for(PelipatanProdukDetailDto pelipatanDetailDto : dto.getProdukDetails()) {
				PlanningPelayananDetail planningPelayananDetail = new PlanningPelayananDetail();
				planningPelayananDetail.setPlanningPelayanan(planningPelayanan);
				planningPelayananDetail.setStrukPelayanan(strukPelayanan);
				planningPelayananDetail.setTglPlanning(tgl);
				planningPelayananDetail.setRuangan(ruangan);
				Alat alat = new Alat();
				alat.setId(3); //set alat, ini bisa berubah.....
				planningPelayananDetail.setAlat(alat);
				planningPelayananDetail.setProduk(produk);
				Produk produkLinen = this.produkDao.findOne(pelipatanDetailDto.getProdukDetailId());
				planningPelayananDetail.setProdukDetail(produkLinen);
						
				Double beratLinen = pelipatanDetailDto.getBeratLinen();
				Integer jumlahLipatan = pelipatanDetailDto.getJumlahLipat();
				Double totalBerat = beratLinen*jumlahLipatan;
				planningPelayananDetail.setJumlahCycle(jumlahLipatan);
				planningPelayananDetail.setQtyProdukDetail(beratLinen);
				planningPelayananDetail.setTotalVolumeProdukDetail(totalBerat);
				planningPelayananDetail = this.planningPelayananDetailDao.save(planningPelayananDetail);
				
				
				//---UPDATE STOCK----
				//update stok detail
				Integer produkDetail = pelipatanDetailDto.getProdukDetailId();
				System.out.println("---Start Update Stock Detail---");
				StokProdukDetail stokProdukDetail = this.stokProdukDetailDao.findbyProdukAndRuangan(produkDetail, ruangan.getId());
				StokProdukDetail resultDetail = null;
				if(stokProdukDetail != null) {
					Double qtyProduk = stokProdukDetail.getQtyProduk();
					Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(String.valueOf(pelipatanDetailDto.getJumlahLipat())));
					stokProdukDetail.setQtyProduk(jumlah);
					resultDetail = this.stokProdukDetailDao.save(stokProdukDetail);
				}
					
				//update stok global
				//System.out.println("---Start Update Stock Global---");
				//StokProdukGlobal stokProdukGlobal = this.stokProdukGlobalDao.findbyProdukAndRuangan(produkDetail, ruangan.getId());
				//StokProdukGlobal resultGlobal = null;
				//if(stokProdukGlobal != null) {
				//	Double qtyProduk = stokProdukGlobal.getQtyProduk();
				//	Double jumlah = qtyProduk + Double.parseDouble(String.valueOf(pelipatanDetailDto.getJumlahLipat()));
				//	stokProdukGlobal.setQtyProduk(jumlah);
				//	resultGlobal = this.stokProdukGlobalDao.save(stokProdukGlobal);
				//}
					
				//update kartustok
				System.out.println("---Start update Kartu Stock---");
				Double jml = Double.parseDouble(String.valueOf(pelipatanDetailDto.getJumlahLipat()));
				String keterangan = "roll press laundry";
				Boolean status = true;
				Produk produkstock =  this.produkDao.findById(produkDetail);
				this.kartuStokService.saveKartuStok(jml, produkstock, ruangan, keterangan, status, tgl);

			}
	
		}
		
		//set petugas pelaksana
		if(CommonUtil.isNotNullOrEmpty(strukPlanning)){
			PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
			Pegawai pegawai = new Pegawai();
			pegawai.setId(dto.getPetugasId());
			planningPelayananPetugas.setPegawai(pegawai);
			planningPelayananPetugas.setPegawaiExec(pegawai);
			planningPelayananPetugas.setStrukPlaning(strukPlanning);
			planningPelayananPetugas.setTglPlanning(tgl);
			planningPelayananPetugas.setTglPelayanan(tgl);
			planningPelayananPetugas.setIsPetugasPepJawab((byte)1);
			planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
		}
		
		//set flag untuk pelipatan setelah dilakukannya roll
		//flanya ditampung di keteranganAmbil
		StrukPelayanan strukPelayananPelipatan = this.strukPelayananDao.findByNoRec(dto.getNoRecStrukPelayanan());
		strukPelayananPelipatan.setKeteranganAmbil("Proses Pelipatan");
		strukPelayananPelipatan = this.strukPelayananDao.save(strukPelayananPelipatan);

		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
		}
		return result;

	}


	@Override
	public Map<String, Object> getProsesRollPress(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesRollPress(startDate, endDate);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesRollPressExternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesRollPressExternal(startDate, endDate);
		for(Map<String, Object>item:listdata){
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> getProsesRollPressByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
						
		List<Map<String, Object>> listdata = this.laundryDao.getProsesRollPressbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("detail", this.laundryDao.getProsesRollPressDetailbyNoRec((String)item.get("noRec")));
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}
	
	@Override
	public Map<String, Object> getProsesRollPressExternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
						
		List<Map<String, Object>> listdata = this.laundryDao.getProsesRollPressbyNoRec(noRec);
		for(Map<String, Object>item:listdata){
			item.put("detail", this.laundryDao.getProsesRollPressDetailbyNoRec((String)item.get("noRec")));
			item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));		
			data.add(item);
		}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> getBahanLaundry() {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getBahanLaundry());
		return result;
	}

	@Override
	public Map<String, Object> getStockLaundryLinenBersih() {
		Map<String, Object> result = new HashMap<>();
		//Integer id = this.loginUserService.getCurrentRuanganId();
		//Ruangan ruangan = this.loginUserService.getCurrentRuangan();
		Ruangan ruangan = this.ruanganDao.findById(93);
		Integer id = ruangan.getId();
		result.put("data", this.laundryDao.getStockLaundryLinenBersih(id));
		return result;
	}
	
	@Override
	public Map<String, Object> getStockBahanLaundry() {
		Map<String, Object> result = new HashMap<>();
		//Integer id = this.loginUserService.getCurrentRuanganId();
		//Ruangan ruangan = this.loginUserService.getCurrentRuangan();
		Ruangan ruangan = this.ruanganDao.findById(93);
		Integer id = ruangan.getId();
		result.put("data", this.laundryDao.getStockBahanLaundry(id));
		return result;
	}

	@Override
	public Map<String, Object> savePenditribusianLinenInternal(PenerimaanLinenExternalDto dto) {
		Map<String, Object> result = new HashMap<>();
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setNostruk(dto.getNoStruk());
		Ruangan ruanganAsal = this.ruanganDao.findById(93); //ruang laundry
		strukPelayanan.setKdruanganasal(ruanganAsal);
		Ruangan ruangTujuan = new Ruangan();
		ruangTujuan.setId(dto.getRuanganId());;
		strukPelayanan.setKdruangan(ruangTujuan);
		strukPelayanan.setKeteranganlainnya("Distribusi Linen");
		strukPelayanan.setQtyproduk(0.0);
		strukPelayanan.setTglstruk(dto.getTglOrder());
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		Pegawai pegawaiPenerima = new Pegawai();
		pegawaiPenerima.setId(dto.getPegawaiOrderId()); //pegawaipenerima
		strukPelayanan.setKdpegawaipenerima(pegawaiPenerima);
		strukPelayanan.setMenyerahkan(this.loginUserService.getLoginUser().getPegawai());
		StrukPelayanan strukPelayananResult = null;
		strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
	
		//if(CommonUtil.isNullOrEmpty(strukPelayanan)){
			for(ProdukLinenExternalDto itemProduk : dto.getProdukLinens()){
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				Produk produk = new Produk();
				produk.setId(itemProduk.getProdukId());
				strukPelayananDetail.setKdproduk(produk);
				strukPelayananDetail.setQtyproduk(itemProduk.getJumlah());
				SatuanStandar satuanStandar = new SatuanStandar();
				//satuanStandar.setId(itemProduk.getSatuanId());
				//strukPelayananDetail.setKdsatuanstandar(satuanStandar);
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setTglpelayanan(dto.getTglOrder());
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail = this.strukPelayananDetailDao.save(strukPelayananDetail);
						
				//UPDATE STOCK
				//Stock berkurang saat pendistribusian barang
				//update stok produk detail
				System.out.println("---Start Update Stock Detail---");
				Integer ruanganAsalStock = ruanganAsal.getId();
				StokProdukDetail stokProdukDetail = this.stokProdukDetailDao.findbyProdukAndRuangan(itemProduk.getProdukId(), ruanganAsalStock);
				StokProdukDetail resultDetail = null;
				if(stokProdukDetail != null) {
					Double qtyProduk = stokProdukDetail.getQtyProduk();
					Double jumlah = qtyProduk - Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
					stokProdukDetail.setQtyProduk(jumlah);
					resultDetail = this.stokProdukDetailDao.save(stokProdukDetail);
				}
				
				//UPDATE STOCK
				//Stock berkurang saat pendistribusian barang
				//update stok global
				//System.out.println("---Start Update Stock Global---");
				//Integer ruanganAsalStock = ruanganAsal.getId();
				//StokProdukGlobal stokProdukGlobal = this.stokProdukGlobalDao.findbyProdukAndRuangan(itemProduk.getProdukId(), ruanganAsalStock);
				//StokProdukGlobal resultGlobal = null;
				//if(stokProdukGlobal != null) {
				//	Double qtyProduk = stokProdukGlobal.getQtyProduk();
				//	Double jumlah = qtyProduk - Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
				//	stokProdukGlobal.setQtyProduk(jumlah);
				//	resultGlobal = this.stokProdukGlobalDao.save(stokProdukGlobal);
				//}
					
				//update kartustok
				System.out.println("---Start update Kartu Stock---");
				Double jml = Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
				String keterangan = "Distribusi Internal Linen";
				Boolean status = true;
				Produk produkstock =  this.produkDao.findById(itemProduk.getProdukId());
				this.kartuStokService.saveKartuStok(jml, produkstock, ruanganAsal, keterangan, status, dto.getTglOrder());

			}
		//}
			
		//update flag noorder distribusi ke noorder pengambilan linen kotor
		//Pada saat pendistribusian linen bersih, berdasarkan dari
		//pengambilan linen kotor dan menghitung waktu 
		StrukPelayanan strukPelayananLinenKotor = this.strukPelayananDao.findByNoRec(dto.getNoRecPengambilanLinenKotor());
		strukPelayananLinenKotor.setTglAmbil(dto.getTglOrder());
		strukPelayananLinenKotor.setNoTerima(strukPelayananResult.getNoRec()); //set flag permintaan yg sdh didistribusikan
		strukPelayananLinenKotor = strukPelayananDao.save(strukPelayananLinenKotor);
		
		if(CommonUtil.isNotNullOrEmpty(strukPelayananResult)) {
			result.put("noRec", strukPelayananResult.getNoRec());
		}
		
		return result;
	}
	
	@Override
	public Map<String, Object> savePenditribusianLinenExternal(PenerimaanLinenExternalDto dto) {
		Map<String, Object> result = new HashMap<>();
		Date tglAmbil = DateUtil.toDate(dto.getTglTerima());
		String noClosing = dto.getNoClosing();
		
		//untuk sementara lock noClosing di lepas
		//nanti jika sudah berjalan, diaktifkan kembali, untuk menjegah tidak bayar
		
		//if(noClosing == null || noClosing.equals("0")){
		//	result.put("message", "Anda belum bayar, barang tidak bisa diambil");
		//}
		
		//StrukPelayanan strukPelayanan = new StrukPelayanan();
		
		StrukPelayanan strukPelayanan = this.strukPelayananDao.findByNoRec(dto.getNoRecStrukPelayanan());
		strukPelayanan.setTglAmbil(tglAmbil);
		//strukPelayanan.setMenyerahkan(this.loginUserService.getLoginUser().getPegawai());
		StrukPelayanan strukPelayananResult = null;
		strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
		
		Ruangan ruanganAsal = this.ruanganDao.findById(93); //ruang laundry

		for(ProdukLinenExternalDto itemProduk : dto.getProdukLinens()){
				
				//UPDATE STOCK
				//Stock berkurang saat pendistribusian barang
				//update stok produk detail
				System.out.println("---Start Update Stock Detail---");
				Integer ruanganAsalStock = ruanganAsal.getId();
				StokProdukDetail stokProdukDetail = this.stokProdukDetailDao.findbyProdukAndRuangan(itemProduk.getProdukId(), ruanganAsalStock);
				StokProdukDetail resultDetail = null;
				if(stokProdukDetail != null) {
					Double qtyProduk = stokProdukDetail.getQtyProduk();
					Double jumlah = qtyProduk - Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
					stokProdukDetail.setQtyProduk(jumlah);
					resultDetail = this.stokProdukDetailDao.save(stokProdukDetail);
				}

				//System.out.println("---Start Update Stock Global---");
				//Integer ruanganAsalStock = ruanganAsal.getId();
				//StokProdukGlobal stokProdukGlobal = this.stokProdukGlobalDao.findbyProdukAndRuangan(itemProduk.getProdukId(), ruanganAsalStock);
				//StokProdukGlobal resultGlobal = null;
				//if(stokProdukGlobal != null) {
				//	Double qtyProduk = stokProdukGlobal.getQtyProduk();
				//	Double jumlah = qtyProduk - Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
				//	stokProdukGlobal.setQtyProduk(jumlah);
				//	resultGlobal = this.stokProdukGlobalDao.save(stokProdukGlobal);
				//}
							
				//Update Kartustok
				System.out.println("---Start update Kartu Stock---");
				Double jml = Double.parseDouble(String.valueOf(itemProduk.getJumlah()));
				String keterangan = "Distribusi Linen External";
				Boolean status = true;
				Produk produkstock =  this.produkDao.findById(itemProduk.getProdukId());
				this.kartuStokService.saveKartuStok(jml, produkstock, ruanganAsal, keterangan, status, dto.getTglOrder());

		}

		if(CommonUtil.isNotNullOrEmpty(strukPelayananResult)) {
			result.put("noRec", strukPelayananResult.getNoRec());
		}
				
		return result;

	}

	@Override
	public Map<String, Object> getDistribusiLinen(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getDistribusiLinen(startDate, endDate));
		return result;
	}

	@Override
	public Map<String, Object> getDistribusiLinenByRuangan(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		Ruangan ruangan = this.loginUserService.getLoginUser().getPegawai().getRuangan();
		Integer ruanganId = ruangan.getId();
		//Integer ruangan = this.loginUserService.getLoginUser().getPegawai().getRuangan();
		result.put("data", this.laundryDao.getDistribusiLinenByRuangan(ruanganId, startDate, endDate));
		return result;
	}

	@Override
	public Map<String, Object> updateTanggalTerimaLinenBersihByRuangan(PenerimaanLinenDto dto) {
		Map<String, Object> result = new HashMap<>();
		
		StrukPelayanan strukPelayanan = this.laundryDao.getDistribusiLinenByNoRec(dto.getNoRecStrukPelayanan());
		Date tglTerima = DateUtil.toDate(dto.getTglTerima());
		strukPelayanan.setTglterimakiriman(tglTerima);
		StrukPelayanan strukPelayananResult = null;
		strukPelayananResult = this.strukPelayananDao.save(strukPelayanan);
		
		//update order laundry internal
		StrukPelayanan updateTgl = this.laundryDao.getUpdateTglTerimaByNoStruk(dto.getNoStruk());
		updateTgl.setTglterimakiriman(tglTerima);
		StrukPelayanan strPelayanan = null;
		strPelayanan = this.strukPelayananDao.save(updateTgl);
		
		if(CommonUtil.isNotNullOrEmpty(strukPelayananResult)) {
			result.put("data", strukPelayananResult.getNoRec());
		}
		
		return result;
	}

	@Override
	public Map<String, Object> getDistribusiLinenBersihDetailByNoRec(String noRec) {

		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
		
		List<Map<String, Object>> header = this.laundryDao.getDistribusiLinenBersihByNoRec(noRec);
		for(Map<String, Object> detail:header){
			detail.put("detail", this.laundryDao.getDistribusiLinenDetailByNoRec((String)detail.get("noRec")));
			data.add(detail);
		}
		
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> getPenerimaanLinenInternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getPenerimaanLinenInternal(startDate, endDate));
		
		return result;
	}

	@Override
	public Map<String, Object> getPenerimaanLinenExternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getPenerimaanLinenExternal(startDate, endDate));
		return result;
	}
	
	//proses cuci external
	//create by iwankasan
	//date : 05.02.2018
	@Override
	public Map<String, Object> saveProsesPencucianExternal(ProsesCuciLinenDto dto) {
		//create StrukPelayanan
		//StrukPelayanan strukPelayanan = new StrukPelayanan();
			
		Date tanggal = DateUtil.toDate(dto.getTglPencucianLinen());
		Date tanggalAkhir = DateUtil.toDate(dto.getTglSelesaiPencucianLinen());
			
		//if(dto.getNoRecStrukPelayanan()!=null){
			StrukPelayanan strukPelayanan = this.strukPelayananDao.findByNoRec(dto.getNoRecStrukPelayanan());
			//strukPelayanan.setNoRec(dto.getNoRecStrukPelayanan());
		//}
		//String noStruk = noUrut("StrukPelayanan"); //"StrukPelayanan"
		//String noStruk = strukOrderService.formatNoUrut("StrukPelayanan", "PCI");
		//strukPelayanan.setNostruk(noStruk);
		//strukPelayanan.setKdruanganasal(loginUserService.getCurrentRuangan());
		Ruangan ruangan = ruanganDao.findOne(93); //ruangan penerima
		//strukPelayanan.setKdruangan(ruangan);
		//strukPelayanan.setKeteranganlainnya("Proses Pencucian External");
		//strukPelayanan.setQtyproduk(dto.getBeratLinen());
		//strukPelayanan.setTglstruk(tanggal);
		//strukPelayanan.setTglterimakiriman(tanggal);
		KelompokTransaksi kelompokTransaksi = new KelompokTransaksi();
		kelompokTransaksi.setId(Integer.parseInt(GetSettingDataFixed("KdKelompokTransaksiLaundry")));
		//strukPelayanan.setKdkelompoktransaksi(kelompokTransaksi);
		//strukPelayanan.setMenyerahkan(loginUserService.getLoginUser().getPegawai());
		//strukPelayanan = this.strukPelayananDao.save(strukPelayanan);
			
		StrukPlanning strukPlanning = new StrukPlanning();
		Ruangan ruanganAsalId = ruanganDao.findOne(dto.getRuanganAsalId());
		strukPlanning.setKdruanganasal(ruanganAsalId);
		strukPlanning.setKdruangan(ruangan);
		strukPlanning.setKdkelompoktransaksi(kelompokTransaksi);
		strukPlanning.setTglplanning(tanggal);
		strukPlanning.setKeteranganlainnya("Proses Pencucian External");
		StrukPlanning strukPlanningResult = this.strukPlanningDao.save(strukPlanning);
		
		//save planning pelayanan
		savePlanningPelayanan(dto, strukPlanning, tanggal, tanggalAkhir, ruangan, strukPelayanan);	
			
		//save bahan yang terpakai
		savePlanningPelayananDbhp(dto, strukPlanning, tanggal);
			
		PlanningPelayananPetugas planningPelayananPetugas = new PlanningPelayananPetugas();
		Pegawai pegawai = new Pegawai();
		pegawai.setId(dto.getPetugasId());
		planningPelayananPetugas.setPegawai(pegawai);
		planningPelayananPetugas.setPegawaiExec(pegawai);
		planningPelayananPetugas.setStrukPlaning(strukPlanning);
		planningPelayananPetugas.setTglPlanning(tanggal);
		planningPelayananPetugas.setRuangan(ruangan);
		planningPelayananPetugas.setTglPelayanan(tanggal);
		planningPelayananPetugas.setIsPetugasPepJawab((byte) 1);
		planningPelayananPetugas = this.planningPelayananPetugasDao.save(planningPelayananPetugas);
			
		Map<String, Object> result = new HashMap<>();
		if(CommonUtil.isNotNullOrEmpty(strukPlanningResult)){
			result.put("noRec", strukPlanningResult.getNoRec());
			result.put("noRecStrukPelayanan", strukPelayanan.getNoRec());
		}
			
		//update stock bahan here
			return result;
	}

	@Override
	public Map<String, Object> getProsesCucianExternal(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listStrukPlanning = this.laundryDao.getProsesCuciExternal(startDate, endDate);
		for(Map<String, Object>listpetugas:listStrukPlanning){
			listpetugas.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)listpetugas.get("noRec")));
			data.add(listpetugas);

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

	@Override
	public Map<String, Object> getProsesCucianExternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> data = new ArrayList<>();
				
		List<Map<String, Object>> listdata = this.laundryDao.getProsesCuciInternalbyNoRec(noRec);
			for(Map<String, Object>item:listdata){
				item.put("petugas", this.laundryDao.getPegawaiProsesCuci((String)item.get("noRec")));
					
				List<Map<String, Object>> listbilas = this.laundryDao.getProsesCuciInternalBilasByNoRec((String)item.get("noRec"));
				for(Map<String, Object>itembilas:listbilas){
					itembilas.put("bahan", this.laundryDao.getProsesCuciInternalBahanByNoRecBilas((String)item.get("noRec"), (String)itembilas.get("bilas")));
					data.add(itembilas);
				}
					
				data.add(item);
					
			}
		result.put("data", data);
		return result;
	}

	@Override
	public Map<String, Object> getDistribusiLinenExternal(String startDate, String endDate) {
		//List<ProsesCuciLinenDto> listDto = new ArrayList<ProsesCuciLinenDto>();
		
		Map<String, Object> result = new HashMap<>();
		List<Map<String, Object>> list = new ArrayList<>();
		
		List<Map<String, Object>> listData = this.laundryDao.getDistribusiLinenExternal(startDate, endDate);
		for(Map<String, Object> map:listData){
			//map.put(arg0, arg1)
			Map<String, Object> tempMap = new HashMap<>();
			String noClosing = (String) map.get("noClosing");
			if(noClosing == null || noClosing.equals("0")) {
				tempMap.put("statusBayar", "Belum Bayar");
			} else {
				tempMap.put("statusBayar", "Sudah Bayar");
			}
			
			String tglAmbil = (String) map.get("tglAmbil");
			if(tglAmbil == null) {
				tempMap.put("statusAmbil", "Belum Di Ambil");
			} else {
				tempMap.put("statusAmbil", "Sudah Di Ambil");
			}
			tempMap.put("noStruk", map.get("nostruk"));
			tempMap.put("noRecStrukPelayanan", map.get("noRecStrukPelayanan"));
			tempMap.put("namaLengkapAmbil", map.get("namaLengkapAmbil"));
			tempMap.put("namaPelanggan", map.get("namaPelanggan"));
			tempMap.put("tglOrder", map.get("tglOrder"));
			tempMap.put("beratLinen", map.get("beratLinen"));
			list.add(tempMap);
		
		}
		
		//return null;
		result.put("data", list);
		return result;
	}

	@Override
	public Map<String, Object> getDistribusiLinenExternalByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		result.put("detail", this.laundryDao.findStrukPelayananByNoRec(noRec));
		return result;
	}
	
	
	@Override
	public Map<String, Object> getPengambilanLinenKotor(String startDate, String endDate) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getPengambilanLinenDariRuangan(startDate, endDate));
		return result;
	}

	@Override
	public Map<String, Object> getPengambilanLinenKotorByNoRec(String noRec) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getPengambilanLinenDariRuanganByNoRec(noRec));
		return result;
	}

	@Override
	public Map<String, Object> getJenisLinen() {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getJenisLinen());
		return result;
	}

	@Override
	public Map<String, Object> getMesinByJenisLinen(Integer idJenis) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getMesinLinenByJenisLinen(idJenis));
		return result;
	}

	@Override
	public Map<String, Object> getMappingProdukByJenisLinen(Integer idJenis, Integer idMesin) {
		Map<String, Object> result = new HashMap<>();
		result.put("data", this.laundryDao.getBahanByJenisLinenMesin(idJenis, idMesin));
		return result;
	}
	
	@Override
	public Map<String, Object> findGrandTarifQtyLaundry(String startDate, String endDate) {
		Double grandTotal = 0.0;
		Double grandSubTotal = 0.0;
		Map<String, Object> result = new HashMap<>();
		
		List<Map<String, Object>> ListRawDetailRekapLaundry = laundryDao.getRawDetailRekapLaundry(startDate, endDate);
		for (Map<String, Object> map : ListRawDetailRekapLaundry) {
			Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer) map.get("idProduk"));
			if (CommonUtil.isNullOrEmpty(harga)) {
				harga = 0.0;
			}
			grandSubTotal += (Double) map.get("qty");
			grandTotal += ((Double) map.get("qty"))*harga;
		}
		
		result.put("grandSubTotal", String.format("%.0f", grandSubTotal));
		result.put("grandTotal", new DecimalFormat("Rp #,##0.00").format(grandTotal));
		return result;
	}

	@Override
	public List<Map<String, Object>> findRuanganTarifQtyLaundry(String startDate, String endDate) {
		List<Map<String, Object>> listResult = new ArrayList<>();
				
		List<Map<String, Object>> listRuangan = laundryDao.getListRuanganRekapLaundry(startDate, endDate);
		for (Map<String, Object> ruangan : listRuangan) {
			Double qtySubTotal = 0.0;
			Double subTotal = 0.0;
			List<Map<String, Object>> ListRawDetailRekapLaundry = laundryDao.getRawDetailRekapLaundryByRuangan(startDate, endDate, (Integer) ruangan.get("idRuangan"));
			Map<String, Object> result = new HashMap<>();
			for (Map<String, Object> map : ListRawDetailRekapLaundry) {
				Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer) map.get("idProduk"));
				if (CommonUtil.isNullOrEmpty(harga)) {
					harga = 0.0;
				}
				qtySubTotal += (Double) map.get("qty");
				subTotal += ((Double) map.get("qty"))*harga;
			}
			result.put("idRuangan", ruangan.get("idRuangan"));
			result.put("namaRuangan", ruangan.get("namaRuangan"));
			result.put("qtySubTotal", String.format("%.0f", qtySubTotal));
			result.put("subTotal", new DecimalFormat("Rp #,##0.00").format(subTotal));
			listResult.add(result);
		}
		return listResult;
	}

	@Override
	public List<Map<String, Object>> findDetailRuanganTarifQtyLaundry(String startDate, String endDate) {
		List<Map<String, Object>> listResult = new ArrayList<>();
		
		List<Map<String, Object>> listRuangan = laundryDao.getListRuanganRekapLaundry(startDate, endDate);
		for (Map<String, Object> ruangan : listRuangan) {
			List<Map<String, Object>> listProduk = laundryDao.getListProdukRekapLaundry(startDate, endDate, (Integer)ruangan.get("idRuangan"));
			for (Map<String, Object> produk : listProduk) {
				List<Map<String, Object>> ListRawDetailRekapLaundry = laundryDao.getRawDetailRekapLaundryByProduk(startDate, endDate, (Integer)produk.get("idRuangan"), (Integer)produk.get("idProduk"));
				for (Map<String, Object> map : ListRawDetailRekapLaundry) {
					Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer) map.get("idProduk"));
					if (CommonUtil.isNullOrEmpty(harga)) {
						harga = 0.0;
					}
					Double subTotal = Double.parseDouble(map.get("qty").toString())*harga;
					map.put("harga", new DecimalFormat("Rp #,##0.00").format(harga));
					map.put("subTotal", new DecimalFormat("Rp #,##0.00").format(subTotal));
					listResult.add(map);
				}
			}
		}
		
		return listResult;
	}

	@Override
	public Map<String, Object> findRawLapLinenPerLayanan(String startDate, String endDate) {
		Map<String, Object> mapListResult = new HashMap<>();
		List<Map<String, Object>> listDataSource = new ArrayList<>();
		
		Double grandQty = 0.0;
		Double grandTotal = 0.0;
		
		List<Map<String, Object>> listProduk = laundryDao.getListProdukRekapLaundry(startDate, endDate);
		for (Map<String, Object> produk : listProduk) {
			List<Map<String, Object>> ListRawLapLinenPerLayanan = laundryDao.getRawLapLinenPerLayanan(startDate, endDate, (Integer) produk.get("idProduk"));
			for (Map<String, Object> map : ListRawLapLinenPerLayanan) {
				Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer) map.get("idProduk"));
				if (CommonUtil.isNullOrEmpty(harga)) {
					harga = 0.0;
				}
				Double totalPendapatan = Double.parseDouble(map.get("qty").toString())*harga;
				grandQty += Double.parseDouble(map.get("qty").toString());
				grandTotal += totalPendapatan;
				
				map.put("totalPendapatan", new DecimalFormat("Rp #,##0.00").format(totalPendapatan));
				listDataSource.add(map);
			}
		}
		mapListResult.put("dataSource", listDataSource);
		mapListResult.put("grandQty", String.format("%.0f", grandQty));
		mapListResult.put("grandTotal", new DecimalFormat("Rp #,##0.00").format(grandTotal));
		return mapListResult;
	}

	@Override
	public Map<String, Object> getOrderLaundrySebelumDiTerimaByRuangan(String startDate, String endDate,
			Integer idRuanganAsal) {
		Map<String, Object> data = new HashMap<>();
		//Ruangan ruanganAsal = new Ruangan();
		//ruanganAsal.setId(loginUserService.getCurrentRuangan().getId());
		//Integer ruanganAsalId = loginUserService.getCurrentRuangan().getId();
		data.put("data", this.laundryDao.getOrderLaundrySebelumDiTerimaByRuangan(startDate, endDate, idRuanganAsal));
		return data;
	}

	@Override
	public Map<String, Object> findGrandTarifQtyCuciLinen(String startDate, String endDate) {
		Double grandRupiah = 0.0;
		Double grandLembar = 0.0;
		Double grandBerat = 0.0;
		Map<String, Object> result = new HashMap<>();
		
		String datePattern = "yyyy-MM-dd";
		Date date = new Date();
		Calendar cal = Calendar.getInstance();
		try {
			date = new SimpleDateFormat(datePattern).parse(startDate);
			cal.setTime(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		int dayMonth = cal.get(Calendar.DAY_OF_MONTH);
		
		List<Map<String, Object>> listGrandRekapCuciLinen = laundryDao.getGrandRekapCuciLinen(startDate,endDate);
		for (Map<String, Object> map : listGrandRekapCuciLinen) {
			Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer)map.get("idProduk"));
			if (CommonUtil.isNullOrEmpty(harga)) {
				harga = 0.0;
			}
			grandLembar += (Double)map.get("qty");
			grandRupiah += ((Double)map.get("qty"))*harga;
			grandBerat += (Double)map.get("berat");
		}
		Double rataanBeratCucian = grandBerat/dayMonth;
		Double rataanLembarCucian = grandLembar/dayMonth;
		
		String grandRupiahTerbilang = angkaToTerbilang(grandRupiah);
		grandRupiahTerbilang += " rupiah";
		
		result.put("grandSubTotal", String.format("%.0f", grandLembar));
		result.put("grandTotal", new DecimalFormat("Rp #,##0.00").format(grandRupiah));
		result.put("grandBerat", String.format("%.0f", grandBerat));
		result.put("rataanBeratCucian", String.format("%.0f", rataanBeratCucian));
		result.put("rataanLembarCucian", String.format("%.0f", rataanLembarCucian));
		result.put("grandRupiahTerbilang", grandRupiahTerbilang);
		
		return result;
	}

	@Override
	public List<Map<String, Object>> findDepartemenTarifQtyCuciLinen(String startDate, String endDate) {
		List<Map<String, Object>> listResult = new ArrayList<>();
		
		List<Map<String, Object>> listDepartemen = laundryDao.getListDepartemenRekapCuciLinen(startDate, endDate);
		for (Map<String, Object> departemen : listDepartemen) {
			Double qtySubTotal = 0.0;
			Double subTotal = 0.0;
			Double beratSubTotal = 0.0;
			List<Map<String, Object>> ListRawDetailRekapCuciLinen = laundryDao.getListRekapCuciLinenByDepartemen(startDate, endDate, (Integer) departemen.get("idDepartemen"));
			Map<String, Object> result = new HashMap<>();
			for (Map<String, Object> map : ListRawDetailRekapCuciLinen) {
				Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer) map.get("idProduk"));
				if (CommonUtil.isNullOrEmpty(harga)) {
					harga = 0.0;
				}
				qtySubTotal += (Double) map.get("qty");
				subTotal += ((Double) map.get("qty"))*harga;
				beratSubTotal += (Double) map.get("berat");
			}
			
			result.put("idDepartemen", departemen.get("idDepartemen"));
			result.put("namaDepartemen", departemen.get("namaDepartemen"));
			result.put("qtySubTotal", String.format("%.0f", qtySubTotal));
			result.put("subTotal", new DecimalFormat("Rp #,##0.00").format(subTotal));
			result.put("beratSubTotal", String.format("%.0f", beratSubTotal));
			
			listResult.add(result);
		}
		return listResult;
	}

	@Override
	public List<Map<String, Object>> findRuanganTarifQtyCuciLinen(String startDate, String endDate) {
		List<Map<String, Object>> listResult = new ArrayList<>();
		
		List<Map<String, Object>> listDepartemen = laundryDao.getListDepartemenRekapCuciLinen(startDate, endDate);
		for (Map<String, Object> departemen : listDepartemen) {
			List<Map<String, Object>> listRuangan = laundryDao.getListRuanganRekapCuciLinen(startDate, endDate, (Integer)departemen.get("idDepartemen"));
			for (Map<String, Object> ruangan : listRuangan) {
				Double qtySubTotal = 0.0;
				Double subTotal = 0.0;
				Double beratSubTotal = 0.0;
				List<Map<String, Object>> ListRawDetailRekapCuciLinen = laundryDao.getListRekapCuciLinenByRuangan(startDate, endDate, (Integer)departemen.get("idDepartemen"), (Integer)ruangan.get("idRuangan"));
				for (Map<String, Object> map : ListRawDetailRekapCuciLinen) {
					Double harga = laundryDao.getHargaStokProdukDetailLaundry((Integer)map.get("idProduk"));
					if (CommonUtil.isNullOrEmpty(harga)) {
						harga = 0.0;
					}
					qtySubTotal += (Double) map.get("qty");
					subTotal += ((Double) map.get("qty"))*harga;
					beratSubTotal += (Double) map.get("berat");
					
					map.put("idDepartemen", departemen.get("idDepartemen"));
					map.put("idRuangan", departemen.get("idRuangan"));
					map.put("namaRuangan", departemen.get("namaRuangan"));
					map.put("qtySubTotal", String.format("%.0f", qtySubTotal));
					map.put("subTotal", new DecimalFormat("Rp #,##0.00").format(subTotal));
					map.put("beratSubTotal", String.format("%.0f", beratSubTotal));
					
					listResult.add(map);
				}
			}
		}
		return listResult;
	}

	@Override
	public String angkaToTerbilang(Double angka) {
		String[] angkaTerbilang={"","Satu","Dua","Tiga","Empat","Lima","Enam","Tujuh","Delapan","Sembilan","Sepuluh","Sebelas"};
		Long angkaLong = angka.longValue();
		if(angkaLong < 12)
			return angkaTerbilang[angkaLong.intValue()];
		if(angkaLong >=12 && angkaLong <= 19)
			return angkaTerbilang[angkaLong.intValue() % 10] + " Belas";
		if(angkaLong >= 20 && angkaLong <= 99)
			return angkaToTerbilang((double) (angkaLong / 10)) + " Puluh " + angkaTerbilang[angkaLong.intValue() % 10];
		if(angkaLong >= 100 && angkaLong <= 199)
			return "Seratus " + angkaToTerbilang((double) (angkaLong % 100));
		if(angkaLong >= 200 && angkaLong <= 999)
			return angkaToTerbilang((double) (angkaLong / 100)) + " Ratus " + angkaToTerbilang((double) (angkaLong % 100));
		if(angkaLong >= 1000 && angkaLong <= 1999)
			return "Seribu " + angkaToTerbilang((double) (angkaLong % 1000));
		if(angkaLong >= 2000 && angkaLong <= 999999)
			return angkaToTerbilang((double) (angkaLong / 1000)) + " Ribu " + angkaToTerbilang((double) (angkaLong % 1000));
		if(angkaLong >= 1000000 && angkaLong <= 999999999)
			return angkaToTerbilang((double) (angkaLong / 1000000)) + " Juta " + angkaToTerbilang((double) (angkaLong % 1000000));
		if(angkaLong >= 1000000000 && angkaLong <= 999999999999L)
			return angkaToTerbilang((double) (angkaLong / 1000000000)) + " Milyar " + angkaToTerbilang((double) (angkaLong % 1000000000));
		if(angkaLong >= 1000000000000L && angkaLong <= 999999999999999L)
			return angkaToTerbilang((double) (angkaLong / 1000000000000L)) + " Triliun " + angkaToTerbilang((double) (angkaLong % 1000000000000L));
		if(angkaLong >= 1000000000000000L && angkaLong <= 999999999999999999L)
			return angkaToTerbilang((double) (angkaLong / 1000000000000000L)) + " Quadrilyun " + angkaToTerbilang((double) (angkaLong % 1000000000000000L));
		return "";
	}
	
	
	
	
	
	
	
}
