package com.jasamedika.medifirst2000.service.impl;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import org.apache.commons.codec.binary.Base64;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.orm.jpa.JpaSystemException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.jasamedika.medifirst2000.converter.BaseConverterImpl;
import com.jasamedika.medifirst2000.dao.HargaNettoProdukByTerimaDao;
import com.jasamedika.medifirst2000.dao.JenisTransaksiDao;
import com.jasamedika.medifirst2000.dao.KelompokProdukDao;
import com.jasamedika.medifirst2000.dao.KelompokTransaksiDao;
import com.jasamedika.medifirst2000.dao.ProdukDao;
import com.jasamedika.medifirst2000.dao.RegistrasiAsetDao;
import com.jasamedika.medifirst2000.dao.RekananDao;
import com.jasamedika.medifirst2000.dao.RuanganDao;
import com.jasamedika.medifirst2000.dao.RunningNumberDao;
import com.jasamedika.medifirst2000.dao.SatuanStandarDao;
import com.jasamedika.medifirst2000.dao.StokProdukGlobalDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDNoBatchDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDao;
import com.jasamedika.medifirst2000.dao.StrukPelayananDetailDao;
import com.jasamedika.medifirst2000.dao.StrukReturDao;
import com.jasamedika.medifirst2000.dao.StrukVerifikasiDao;
import com.jasamedika.medifirst2000.dao.custom.StrukPelayananDetailDaoCustom;
import com.jasamedika.medifirst2000.entities.AsalProduk;
import com.jasamedika.medifirst2000.entities.HargaNettoProdukByTerima;
import com.jasamedika.medifirst2000.entities.JenisLimbahB3Masuk;
import com.jasamedika.medifirst2000.entities.KartuPengendaliDetail;
import com.jasamedika.medifirst2000.entities.KelompokTransaksi;
import com.jasamedika.medifirst2000.entities.LoginUser;
import com.jasamedika.medifirst2000.entities.Pegawai;
import com.jasamedika.medifirst2000.entities.Produk;
import com.jasamedika.medifirst2000.entities.RegistrasiAset;
import com.jasamedika.medifirst2000.entities.Rekanan;
import com.jasamedika.medifirst2000.entities.Ruangan;
import com.jasamedika.medifirst2000.entities.RunningNumber;
import com.jasamedika.medifirst2000.entities.SatuanStandar;
import com.jasamedika.medifirst2000.entities.SatuanWaktuKesling;
import com.jasamedika.medifirst2000.entities.StokProdukDetail;
import com.jasamedika.medifirst2000.entities.StokProdukGlobal;
import com.jasamedika.medifirst2000.entities.StrukOrder;
import com.jasamedika.medifirst2000.entities.StrukPelayanan;
import com.jasamedika.medifirst2000.entities.StrukPelayananDNoBatch;
import com.jasamedika.medifirst2000.entities.StrukPelayananDPetugas;
import com.jasamedika.medifirst2000.entities.StrukPelayananDetail;
import com.jasamedika.medifirst2000.entities.StrukRetur;
import com.jasamedika.medifirst2000.entities.StrukVerifikasi;
import com.jasamedika.medifirst2000.exception.ServiceVOException;
import com.jasamedika.medifirst2000.service.KartuStokService;
import com.jasamedika.medifirst2000.service.LoginUserService;
import com.jasamedika.medifirst2000.service.PphpService;
import com.jasamedika.medifirst2000.service.StokProdukGlobalService;
import com.jasamedika.medifirst2000.service.StrukOrderService;
import com.jasamedika.medifirst2000.service.StrukPelayananService;
import com.jasamedika.medifirst2000.util.CommonUtil;
import com.jasamedika.medifirst2000.util.DateUtil;
import com.jasamedika.medifirst2000.util.HibernateInitialize;
import com.jasamedika.medifirst2000.util.StringUtil;
import com.jasamedika.medifirst2000.vo.AsalProdukVO;
import com.jasamedika.medifirst2000.vo.DetilPenerimaanVO;
import com.jasamedika.medifirst2000.vo.InputNoBatchVO;
import com.jasamedika.medifirst2000.vo.JenisLimbahB3MasukVO;
import com.jasamedika.medifirst2000.vo.KartuPengendaliDetailVO;
import com.jasamedika.medifirst2000.vo.KirimPesananBarangDetailVO;
import com.jasamedika.medifirst2000.vo.KirimPesananBarangVO;
import com.jasamedika.medifirst2000.vo.PegawaiVO;
import com.jasamedika.medifirst2000.vo.PemakaianBarangHabisPakaiDetailVO;
import com.jasamedika.medifirst2000.vo.PemakaianBarangHabisPakaiVO;
import com.jasamedika.medifirst2000.vo.PenerimaanBarangDetailVO;
import com.jasamedika.medifirst2000.vo.PenerimaanBarangVO;
import com.jasamedika.medifirst2000.vo.ProdukVO;
import com.jasamedika.medifirst2000.vo.RekananVO;
import com.jasamedika.medifirst2000.vo.ReturSupplierDetailVO;
import com.jasamedika.medifirst2000.vo.ReturSupplierVO;
import com.jasamedika.medifirst2000.vo.RuanganVO;
import com.jasamedika.medifirst2000.vo.SatuanStandarVO;
import com.jasamedika.medifirst2000.vo.SatuanWaktuKeslingVO;
import com.jasamedika.medifirst2000.vo.StrukOrderVO;
import com.jasamedika.medifirst2000.vo.StrukPelayananDNoBatchVO;
import com.jasamedika.medifirst2000.vo.StrukPelayananDPetugasVO;
import com.jasamedika.medifirst2000.vo.StrukPelayananDetailVO;
import com.jasamedika.medifirst2000.vo.StrukPelayananVO;
import com.jasamedika.medifirst2000.vo.UploadExcelVO;

/**
 * 
 * @author Shakato
 */
@Service("StrukPelayananService")
public class StrukPelayananServiceImpl extends BaseAngaranServiceImpl
		implements StrukPelayananService<StrukPelayananVO> {
	
	@Autowired
	StrukPelayananDao strukPelayananDao;

	@Value("${reportDirectory}")
	String reportDirectory;

	@Autowired
	private JenisTransaksiDao jenisTransaksiDao;

	@Autowired
	private StrukOrderService strukOrderService;

	@Autowired
	private StrukReturDao strukReturDao;

	@Autowired
	private KelompokProdukDao kelompokProdukDao;

	@Autowired
	private StokProdukGlobalService stokProdukGlobalService;

	@Autowired
	HargaNettoProdukByTerimaDao hargaNettoProdukByTerimaDao;

	@Autowired
	RuanganDao ruanganDao;

	@Autowired
	private StrukVerifikasiDao strukVerifikasiDao;

	@Autowired
	private KartuStokService kartuStokService;

	@Autowired
	private PphpService pphpService;

	@Autowired
	private SatuanStandarDao satuanStandarDao;

	@Autowired
	private StrukPelayananDetailDaoCustom strukPelayananDetailDaoCustom;

	@Autowired
	private RekananDao rekananDao;

	@Autowired
	StrukPelayananDNoBatchDao strukPelayananDNoBatchDao;

	@Autowired
	StrukPelayananDetailDao strukPelayananDetailDao;

	@Autowired
	private ProdukDao produkDao;

	@Autowired
	private RegistrasiAsetDao registrasiAsetDao;

	@Autowired
	private LoginUserService loginUserService;

	@Autowired
	private KelompokTransaksiDao kelompokTransaksiDao;

	@Autowired
	private BaseConverterImpl<StrukPelayananVO, StrukPelayanan> strukPelayananConverter;

	@Autowired
	private BaseConverterImpl<JenisLimbahB3MasukVO, JenisLimbahB3Masuk> jenisLimbahB3MasukConverter;

	@Autowired
	private BaseConverterImpl<SatuanWaktuKeslingVO, SatuanWaktuKesling> satuanWaktuKeslingConverter;

	@Autowired
	private BaseConverterImpl<StrukPelayananDetailVO, StrukPelayananDetail> strukPelayananDetailConverter;

	@Autowired
	private BaseConverterImpl<StrukPelayananDNoBatchVO, StrukPelayananDNoBatch> strukPelayananDNoBatchConverter;

	@Autowired
	private BaseConverterImpl<StrukPelayananDPetugasVO, StrukPelayananDPetugas> strukPelayananDPetugasConverter;

	@Autowired
	private BaseConverterImpl<KartuPengendaliDetailVO, KartuPengendaliDetail> kartuPengendaliDetailConverter;

	@Autowired
	private BaseConverterImpl<StrukOrderVO, StrukOrder> strukOrderConverter;

	@Autowired
	private BaseConverterImpl<RuanganVO, Ruangan> ruanganConverter;

	@Autowired
	private BaseConverterImpl<ProdukVO, Produk> produkConverter;

	@Autowired
	private BaseConverterImpl<PegawaiVO, Pegawai> pegawaiConverter;

	@Autowired
	private BaseConverterImpl<RekananVO, Rekanan> rekananConverter;

	@Autowired
	private RunningNumberDao runningNumberDao;

	@Autowired
	private StokProdukGlobalDao stokProdukGlobalDao;

	@Autowired
	private BaseConverterImpl<AsalProdukVO, AsalProduk> asalProdukConverter;

	@Autowired
	private BaseConverterImpl<SatuanStandarVO, SatuanStandar> satuanStandarConverter;

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

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

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

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

	@Override
	public StrukPelayananVO findById(String key) throws JpaSystemException {
		return null;
	}

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

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

	@Override
	@Transactional(readOnly = false)
	public StrukPelayananDNoBatch saveStrukPelayananDetailService(StrukPelayananDNoBatchVO vo,
			StrukPelayanan strukPelayanan) {

		StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
		StrukPelayananDNoBatch strukPelayananDNoBatch = new StrukPelayananDNoBatch();
		try {
			// vo.setKdruangan(strukPelayanan.getKdruangan());
			// //vo.setkdr(strukPelayanan.getKdruangan());
			// vo.setKdruangan(strukPelayanan.getKdruangan());
			strukPelayananDetailConverter.setUseGson(true);
			strukPelayananDNoBatchConverter.setUseGson(true);
			strukPelayananDNoBatch = strukPelayananDNoBatchConverter.transferVOToModel(vo.ToMap(),
					new StrukPelayananDNoBatch());
			strukPelayananDetail = strukPelayananDetailConverter.transferVOToModel(vo.ToMap(),
					new StrukPelayananDetail());
			// strukPelayananDetail.setHargadiscount(0.0);//
			Ruangan kdruangan = new Ruangan();
			kdruangan.setId(strukPelayanan.getKdruangan().getId());
			strukPelayananDNoBatch.setKdruangan(kdruangan);

			strukPelayananDetail.setKdruangan(kdruangan);
			Ruangan kdasalruangan = new Ruangan();
			kdasalruangan.setId(strukPelayanan.getKdruanganasal().getId());
			strukPelayananDetail.setHargadiscount(0.0);
			strukPelayananDetail.setHargadiscount(0.0);

			strukPelayananDetail.setHargadiscountgive(0.0);
			strukPelayananDetail.setHargadiscountsave(0.0);
			strukPelayananDetail.setHarganetto(0.0);
			strukPelayananDetail.setHargapph(0.0);
			strukPelayananDetail.setHargappn(0.0);
			strukPelayananDetail.setHargasatuan(0.0);
			strukPelayananDetail.setHargasatuandijamin(0.0);
			strukPelayananDetail.setHargasatuanppenjamin(0.0);
			strukPelayananDetail.setHargasatuanpprofile(0.0);
			strukPelayananDetail.setHargatambahan(0.0);
			strukPelayananDetail.setHargatambahan(0.0);
			strukPelayananDetail.setPersendiscount(0.0);
			strukPelayananDetail.setQtyproduk(vo.getQtyproduk());
			strukPelayananDetail.setQtyorang((byte) 0);
			strukPelayananDetail.setIsonsiteservice((byte) 0);
			strukPelayananDetail.setQtyprodukoutext(0.0);
			strukPelayananDetail.setQtyprodukoutint(0.0);
			strukPelayananDetail.setQtyprodukretur(0.0);
			strukPelayananDetail.setSatuan("");
			strukPelayananDetail.setTglpelayanan(strukPelayanan.getTglstruk());

			strukPelayananDetail.setHargasatuanpprofile(0.0);
			strukPelayananDetail.setHargasatuanpprofile(0.0);

			strukPelayananDetail.setKdruanganasal(kdasalruangan);
			strukPelayananDetail.setObjectProdukId(vo.getKdproduk().getId());

			AsalProduk kdasalproduk = new AsalProduk();
			kdasalproduk.setId(Integer.parseInt(GetSettingDataFixed("KdAsalProdukPMI")));
			strukPelayananDetail.setKdasalproduk(kdasalproduk);
			strukPelayananDNoBatch.setKdasalproduk(kdasalproduk);

			strukPelayananDNoBatch.setQtyproduk(strukPelayananDetail.getQtyproduk());
			strukPelayananDNoBatch.setQtyprodukoutext(0.0);
			strukPelayananDNoBatch.setQtyprodukoutint(0.0);
			strukPelayananDNoBatch.setTglpelayanan(strukPelayananDetail.getTglpelayanan());
			strukPelayananDNoBatch.setNobatch("");
			strukPelayananDNoBatchConverter.setUseGson(true);

		} catch (IllegalArgumentException | IllegalAccessException e) {
			e.printStackTrace();
		}
		StrukPelayanan strukPelayananLocal = new StrukPelayanan();
		strukPelayananLocal.setNoRec(strukPelayanan.getNoRec());
		strukPelayananDetail.setNostruk(strukPelayananLocal);
		strukPelayananDNoBatch.setNostruk(strukPelayananDetail);

		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getNostruk())) {
			strukPelayananDetail = strukPelayananDetailDao.save(strukPelayananDetail);
		}
		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getNostruk())) {
			strukPelayananDNoBatch.setNostruk(strukPelayananDetail);
			strukPelayananDNoBatchDao.save(strukPelayananDNoBatch);
		}

		// StrukPelayanan model = strukPelayananDao.save(strukPelayanan);
		Map<String, Object> result = new HashMap<String, Object>();
		if (CommonUtil.isNotNullOrEmpty(strukPelayananDNoBatch)) {
			result.put("noRec", strukPelayananDNoBatch.getNoRec());

		}
		return strukPelayananDNoBatch;
	}

	@Override
	public StrukPelayanan saveStrukPelayananService(StrukPelayananVO vo) {
		StrukPelayanan strukPelayananDetail = new StrukPelayanan();
		strukPelayananConverter.setUseGson(true);
		strukPelayananDetail = strukPelayananConverter.transferVOToModel(vo, new StrukPelayanan());
		strukPelayananDetail.setKdkelompoktransaksi(
				kelompokTransaksiDao.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdLimbahInStruk"))));
		if (CommonUtil.isNotNullOrEmpty(vo.getJenisLimbahB3Masuk())) {
			strukPelayananDetail.setJenisLimbahB3Masuk(jenisLimbahB3MasukConverter
					.transferVOToModel(vo.getJenisLimbahB3Masuk(), new JenisLimbahB3Masuk()));
		}
		Ruangan kdruangan = new Ruangan();
		strukPelayananDetail.setNostruk(getRunningNumber("StrukPelayanan"));
		kdruangan.setId(vo.getKdruangan().getId());
		strukPelayananDetail.setKdruangan(kdruangan);
		Ruangan kdruanganasal = new Ruangan();
		kdruanganasal.setId(vo.getKdruanganasal().getId());
		strukPelayananDetail.setKdruanganasal(kdruanganasal);
		SatuanWaktuKesling waktuKesling = new SatuanWaktuKesling();
		if (vo.getSatuanWaktuKesling() != null) {
			waktuKesling.setId(vo.getSatuanWaktuKesling().getId());
			strukPelayananDetail.setSatuanWaktuKesling(waktuKesling);
		}
		strukPelayananDetail = strukPelayananDao.save(strukPelayananDetail);
		return strukPelayananDetail;
	}
	
	public StrukPelayanan updateStrukPelayananService(StrukPelayananVO vo){
		StrukPelayanan strukPelayananDetail = new StrukPelayanan();
		
		strukPelayananDetail = strukPelayananConverter.transferVOToModel(vo, new StrukPelayanan());
		strukPelayananDetail.setKdkelompoktransaksi(
				kelompokTransaksiDao.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdLimbahInStruk"))));
		if (CommonUtil.isNotNullOrEmpty(vo.getJenisLimbahB3Masuk())) {
			strukPelayananDetail.setJenisLimbahB3Masuk(jenisLimbahB3MasukConverter
					.transferVOToModel(vo.getJenisLimbahB3Masuk(), new JenisLimbahB3Masuk()));
		}
		Ruangan kdruangan = new Ruangan();
		strukPelayananDetail.setNostruk(getRunningNumber("StrukPelayanan"));
		kdruangan.setId(vo.getKdruangan().getId());
		strukPelayananDetail.setKdruangan(kdruangan);
		Ruangan kdruanganasal = new Ruangan();
		kdruanganasal.setId(vo.getKdruanganasal().getId());
		strukPelayananDetail.setKdruanganasal(kdruanganasal);
		SatuanWaktuKesling waktuKesling = new SatuanWaktuKesling();
		if (vo.getSatuanWaktuKesling() != null) {
			waktuKesling.setId(vo.getSatuanWaktuKesling().getId());
			strukPelayananDetail.setSatuanWaktuKesling(waktuKesling);
		}
		
		StrukPelayanan strukPelayanan = strukPelayananDao.save(strukPelayananDetail);
		return strukPelayananDetail;
	}
	
	@Override
	public void deleteStrukPelayananService(String noRec) {
		StrukPelayanan strukPelayananDetail = new StrukPelayanan();
		strukPelayananDetail = strukPelayananDao.findByNoRec(noRec);
		strukPelayananDetail.setStatusEnabled(false);
		strukPelayananDao.save(strukPelayananDetail);
	}

	@Override
	@Transactional(readOnly = false)
	public StrukPelayananDetail saveStrukPelayananDetailKesling(StrukPelayananDetailVO vo,
			StrukPelayanan strukPelayanan) throws IllegalAccessException {

		StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
		try {
			strukPelayananDetailConverter.setUseGson(true);

			if (CommonUtil.isNotNullOrEmpty(vo)) {
				System.out.println("==================dikonvert=====================");
				strukPelayananDetail = strukPelayananDetailConverter.transferVOToModel(vo, new StrukPelayananDetail());
			}

			Ruangan kdruangan = new Ruangan();
			kdruangan.setId(strukPelayanan.getKdruangan().getId());

			strukPelayananDetail.setKdruangan(kdruangan);
			Ruangan kdasalruangan = new Ruangan();
			kdasalruangan.setId(strukPelayanan.getKdruanganasal().getId());
			strukPelayananDetail.setHargadiscount(0.0);
			strukPelayananDetail.setHargadiscount(0.0);

			strukPelayananDetail.setHargadiscountgive(0.0);
			strukPelayananDetail.setHargadiscountsave(0.0);
			strukPelayananDetail.setHarganetto(0.0);
			strukPelayananDetail.setHargapph(0.0);
			strukPelayananDetail.setHargappn(0.0);
			strukPelayananDetail.setHargasatuan(0.0);
			strukPelayananDetail.setHargasatuandijamin(0.0);
			strukPelayananDetail.setHargasatuanppenjamin(0.0);
			strukPelayananDetail.setHargasatuanpprofile(0.0);
			strukPelayananDetail.setHargatambahan(0.0);
			strukPelayananDetail.setHargatambahan(0.0);
			strukPelayananDetail.setPersendiscount(0.0);

			strukPelayananDetail.setQtyproduk(strukPelayanan.getQtyproduk());
			strukPelayananDetail.setQtyorang((byte) 0);
			strukPelayananDetail.setIsonsiteservice((byte) 0);
			strukPelayananDetail.setQtyprodukoutext(0.0);
			strukPelayananDetail.setQtyprodukoutint(0.0);
			strukPelayananDetail.setQtyprodukretur(0.0);
			strukPelayananDetail.setSatuan("");
			strukPelayananDetail.setTglpelayanan(strukPelayanan.getTglstruk());
			strukPelayananDetail.setMaksimalPenyimpanan(vo.getMaksimalPenyimpanan());
			strukPelayananDetail.setHargasatuanpprofile(0.0);
			strukPelayananDetail.setHargasatuanpprofile(0.0);

			strukPelayananDetail.setKdruanganasal(kdasalruangan);

			AsalProduk kdasalproduk = new AsalProduk();
			kdasalproduk.setId(Integer.parseInt(GetSettingDataFixed("KdAsalProdukPMI")));
			strukPelayananDetail.setKdasalproduk(kdasalproduk);

			StrukPelayanan strukPelayananLocal = new StrukPelayanan();
			strukPelayananLocal.setNoRec(strukPelayanan.getNoRec());
			strukPelayananDetail.setNostruk(strukPelayananLocal);

			LoginUser p = loginUserService.getLoginUser();

			if (CommonUtil.isNotNullOrEmpty(p.getPegawai())) {
				StrukPelayananDPetugas strukPelayananDPetugas = new StrukPelayananDPetugas();
				strukPelayananDPetugas.setNostruk(strukPelayananDetail);
				strukPelayananDPetugas.setPetugasPengirim(vo.getPetugasString());
				strukPelayananDPetugas.setKdpegawai(p.getPegawai());
				strukPelayananDetail.getStrukPelayananDPetugas().add(strukPelayananDPetugas);
			}

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

		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getNostruk())) {
			strukPelayananDetailDao.save(strukPelayananDetail);
		}

		Map<String, Object> result = new HashMap<String, Object>();
		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail)) {
			result.put("noRec", strukPelayananDetail.getNoRec());

		}
		return strukPelayananDetail;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> findAllStrukPelayananLimbahMasuk() {
		Map<String, Object> result = new HashMap<String, Object>();
		List<StrukPelayananDetail> resultModel = (List<StrukPelayananDetail>) strukPelayananDao.findStrukLimbahMasuk();
		List<StrukPelayananDetailVO> listVo = new ArrayList<StrukPelayananDetailVO>();

		for (StrukPelayananDetail model : resultModel) {
			StrukPelayananDetailVO vo = new StrukPelayananDetailVO();

			if (CommonUtil.isNotNullOrEmpty(model.getStrukPelayananDPetugas())) {
				for (StrukPelayananDPetugas petugas : model.getStrukPelayananDPetugas()) {
					if (CommonUtil.isNotNullOrEmpty(petugas.getPetugasPengirim())) {
						vo.setPetugasString(petugas.getPetugasPengirim());
					}
				}
			}

			if (CommonUtil.isNotNullOrEmpty(model.getKdproduk())) {
				Produk p = HibernateInitialize.initializeAndUnproxy(model.getKdproduk());
				vo.setKdproduk(produkConverter.transferModelToVO(p, new ProdukVO()));
			}
			vo.setTglpelayanan(model.getTglpelayanan());
			vo.setQtyproduk(model.getQtyproduk());
			if (CommonUtil.isNotNullOrEmpty(model.getNostruk())) {
				if (CommonUtil.isNotNullOrEmpty(model.getNostruk().getSatuanWaktuKesling())) {
					vo.setSatuanWaktuKesling(satuanWaktuKeslingConverter
							.transferModelToVO(model.getNostruk().getSatuanWaktuKesling(), new SatuanWaktuKeslingVO()));
				}
			}
			if (CommonUtil.isNotNullOrEmpty(model.getKdruangan())) {
				Ruangan r = HibernateInitialize.initializeAndUnproxy(model.getKdruangan());
				vo.setKdruangan(ruanganConverter.transferModelToVO(r, new RuanganVO()));
			}

			vo.setMaksimalPenyimpanan(model.getMaksimalPenyimpanan());

			listVo.add(vo);
		}
		if (CommonUtil.isNotNullOrEmpty(listVo)) {
			result.put("limbahB3Masuk", listVo);
			result.put("dataFound", true);
		} else {
			result.put("dataFound", false);
		}
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> savePenerimaanBarang(PenerimaanBarangVO vo) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		List<StrukPelayananDetail> listStrukPelayananDetail = new ArrayList<StrukPelayananDetail>();
		strukPelayanan.setTglterimakiriman(vo.getTanggalTerima());
		strukPelayanan.setNofaktur(vo.getNoFaktur());
		String noUrut = strukOrderService.formatNoUrut("Penerimaan Supplier", "PNB");
		strukPelayanan.setNostruk(noUrut);
		strukPelayanan.setNostruk_intern(noUrut);
		strukPelayanan.setTglfaktur(vo.getTanggalFaktur());
		strukPelayanan.setKdruangan(getRuanganByUserLogin());
		strukPelayanan.setTgljatuhtempo(vo.getTanggalJatuhTempo());
		strukPelayanan.setTotalbeamaterai(vo.getTotalBeaMaterai());
		strukPelayanan.setTglstruk(new Date());
		strukPelayanan.setNoDokumen(vo.getNoDokumen());
		strukPelayanan.setTglDokumen(vo.getTglDokumen());
		strukPelayanan.setNoPesanan(vo.getNoPesanan());
		strukPelayanan.setNoSppb(vo.getNoSppb());
		strukPelayanan.setTanggalSpk(vo.getTanggalSpk());
		strukPelayanan.setNoKontrak(vo.getNoKontrak());
		strukPelayanan.setTanggalKontrak(vo.getTanggalKontrak());
		strukPelayanan.setKeteranganlainnya("Penerimaan dari supplier");
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPenerimaanBarangLogistik"))));
		if (CommonUtil.isNotNullOrEmpty(vo.getSupplier())) {
			strukPelayanan.setKdrekanan(rekananConverter.transferVOToModel(vo.getSupplier(), new Rekanan()));
		}

		if (CommonUtil.isNotNullOrEmpty(vo.getMenyerahkan())) {
			strukPelayanan.setMenyerahkan(pegawaiConverter.transferVOToModel(vo.getMenyerahkan(), new Pegawai()));
		}

		if (CommonUtil.isNotNullOrEmpty(vo.getMenerima())) {
			strukPelayanan.setMenerima(pegawaiConverter.transferVOToModel(vo.getMenerima(), new Pegawai()));
		}

		if (CommonUtil.isNotNullOrEmpty(vo.getMengetahui())) {
			strukPelayanan.setMengetahui(pegawaiConverter.transferVOToModel(vo.getMengetahui(), new Pegawai()));
		}

		if (CommonUtil.isNotNullOrEmpty(vo.getPjPenerima())) {
			strukPelayanan.setPjPenerima(pegawaiConverter.transferVOToModel(vo.getPjPenerima(), new Pegawai()));
		}

		strukPelayanan.setVerifikasi("1");

		if (CommonUtil.isNotNullOrEmpty(vo.getPenerimaanBarangDetail())) {
			for (PenerimaanBarangDetailVO penerimaanBarangDetailVO : vo.getPenerimaanBarangDetail()) {
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				strukPelayananDetail.setQtyproduk(penerimaanBarangDetailVO.getQtyproduk());
				strukPelayananDetail.setTglKadaluarsa(penerimaanBarangDetailVO.getTanggalKadaluarsa());
				strukPelayananDetail.setNobatch(penerimaanBarangDetailVO.getNoBatch());
				strukPelayananDetail.setHargasatuan(penerimaanBarangDetailVO.getHarga());
				strukPelayananDetail.setPersendiscount(penerimaanBarangDetailVO.getDiscount());
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscountgive(0.0);
				strukPelayananDetail.setHargadiscountsave(0.0);
				strukPelayananDetail.setHarganetto(0.0);
				strukPelayananDetail.setHargapph(0.0);
				strukPelayananDetail.setHargappn(0.0);
				strukPelayananDetail.setHargasatuandijamin(0.0);
				strukPelayananDetail.setHargasatuanppenjamin(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setQtyorang((byte) 0);
				strukPelayananDetail.setIsonsiteservice((byte) 0);
				strukPelayananDetail.setQtyprodukoutext(0.0);
				strukPelayananDetail.setQtyprodukoutint(0.0);
				strukPelayananDetail.setQtyprodukretur(0.0);
				strukPelayananDetail.setSatuan("");
				strukPelayananDetail.setTglpelayanan(strukPelayanan.getTglstruk());

				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);

//				noVerifikasi(strukPelayananDetail);// add by Arya

				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getProduk())) {
					strukPelayananDetail.setKdproduk(
							produkConverter.transferVOToModel(penerimaanBarangDetailVO.getProduk(), new Produk()));
				}
				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getAsalProduk())) {
					strukPelayananDetail.setKdasalproduk(asalProdukConverter
							.transferVOToModel(penerimaanBarangDetailVO.getAsalProduk(), new AsalProduk()));
				}
				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getSatuanTerima())) {
					strukPelayananDetail.setKdsatuanstandar(satuanStandarConverter
							.transferVOToModel(penerimaanBarangDetailVO.getSatuanTerima(), new SatuanStandar()));
				}
				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getKartuPengendaliDetail())) {
					strukPelayananDetail.setKartuPengendaliDetail(kartuPengendaliDetailConverter.transferVOToModel(
							penerimaanBarangDetailVO.getKartuPengendaliDetail(), new KartuPengendaliDetail()));
				}
				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getStrukPelayananDetail().getNoRec())) {
					StrukPelayananDetail s = strukPelayananDetailDao
							.findOne(penerimaanBarangDetailVO.getStrukPelayananDetail().getNoRec());
					strukPelayananDetail.setStrukPelayananDetail(s);
				}

				if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getKdproduk())
						&& CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getKdsatuanstandar())) {
					Produk p = produkDao.findOne(strukPelayananDetail.getKdproduk().getId());
					SatuanStandar satuanTujuan = satuanStandarDao
							.findOne(strukPelayananDetail.getKdsatuanstandar().getId());
					SatuanStandar satuanAsal = new SatuanStandar();

					if (CommonUtil.isNotNullOrEmpty(p.getSatuanStandar())) {
						satuanAsal = p.getSatuanStandar();
					}

					if (CommonUtil.isNotNullOrEmpty(satuanAsal) && CommonUtil.isNotNullOrEmpty(satuanTujuan)
							&& CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getQtyproduk())) {
						strukPelayananDetail.setHasilKonversi(pphpService.konversiKali(strukPelayananDetail.getObjectProdukId(), satuanAsal.getId(),
								satuanTujuan.getId(), strukPelayananDetail.getQtyproduk()));
					}
					strukPelayananDetail.getRegistrasiAsset().clear();
					strukPelayananDetail.getRegistrasiAsset()
							.addAll(registrasiAsset(penerimaanBarangDetailVO, strukPelayanan, strukPelayananDetail));
				}
				strukPelayanan.getStrukPelayananDetail().add(strukPelayananDetail);
				strukPelayanan.getHargaNettoProdukByTerima()
						.add(initializeHargaNettoProdukByTerima(strukPelayananDetail));

				if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getDetilPenerimaan())) {
					strukPelayananDetail.getStokProdukDetail().addAll(initializeStokProdukDetail(
							penerimaanBarangDetailVO.getDetilPenerimaan(), strukPelayananDetail));
				}
				List<StokProdukDetail> dataList = new ArrayList<StokProdukDetail>();

				Produk p = produkDao.findByIdProduk(penerimaanBarangDetailVO.getProduk().getId());
				SatuanStandar satuanTujuan = satuanStandarDao
						.findOne(strukPelayananDetail.getKdsatuanstandar().getId());
				SatuanStandar satuanAsal = new SatuanStandar();
				if (CommonUtil.isNotNullOrEmpty(p.getSatuanStandar())) {
					satuanAsal = HibernateInitialize.initializeAndUnproxy(p.getSatuanStandar());
				}
				if (CommonUtil.isNotNullOrEmpty(p)) {
					if (CommonUtil.isNotNullOrEmpty(p.getDetailJenisProduk())) {
						if (p.getDetailJenisProduk().getIsRegistrasiAset() == 0) {
							if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getDetilPenerimaan())) {
								for (DetilPenerimaanVO detailPenerimaan : penerimaanBarangDetailVO
										.getDetilPenerimaan()) {

									Double persenPpn = 0.0;
									Double persenDiskon = 0.0;
									Double ppn = 0.0;
									Double diskon = 0.0;
									Double hargaSatuan = 0.0;

									if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getPersenppn())) {
										persenPpn = strukPelayananDetail.getPersenppn();
									}
									if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getPersendiscount())) {
										persenDiskon = strukPelayananDetail.getPersendiscount();
									}

									if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getHargasatuan())) {
										hargaSatuan = strukPelayananDetail.getHargasatuan();
									}

									ppn = ((persenDiskon / hargaSatuan) * 100);
									diskon = ((persenPpn / hargaSatuan) * 100);
									Double hargaNetto1 = hargaSatuan + ppn;
									Double hargaNetto2 = hargaNetto1 - diskon;

									StokProdukDetail stokProdukDetail = new StokProdukDetail();
									stokProdukDetail.setNobatch(detailPenerimaan.getNoBatch());
									stokProdukDetail.setAsalProduk(strukPelayananDetail.getKdasalproduk());
									stokProdukDetail.setHargaDiscount(strukPelayananDetail.getHargadiscount());
									stokProdukDetail.setProduk(strukPelayananDetail.getKdproduk());
									stokProdukDetail.setQtyProduk(pphpService.konversiKali(p.getId(), satuanAsal.getId(),
											satuanTujuan.getId(), detailPenerimaan.getQty()));
									stokProdukDetail.setQtyProdukOnHand(new Double(0.0));
									stokProdukDetail.setQtyProdukOutInt(new Double(0.0));
									stokProdukDetail.setQtyProdukOutExt(new Double(0.0));
									stokProdukDetail.setTglpelayanan(new Date());
									stokProdukDetail.setTglkadaluarsa(detailPenerimaan.getTanggalKadaluarsa());
									stokProdukDetail.setPersenDiscount(strukPelayananDetail.getPersendiscount());
									stokProdukDetail.setRuangan(getRuanganByUserLogin());
									stokProdukDetail.setStatusEnabled(true);
									stokProdukDetail.setHargaNetto1(hargaNetto1);
									stokProdukDetail.setHargaNetto2(hargaNetto2);
									stokProdukDetail.setStrukPelayanan(strukPelayanan);
									dataList.add(stokProdukDetail);
								}
							}
							strukPelayananDetail.getStokProdukDetail().clear();
							strukPelayananDetail.getStokProdukDetail().addAll(dataList);
							
							// update stok Produk Global &stok Produk Detail
							updateStok(strukPelayananDetail);
						}
					}
				}
				Ruangan r = getRuanganByUserLogin();
				Rekanan rek = rekananDao.findOne(vo.getSupplier().getId());
				String keterangan = "terima dari supplier " + rek.getNamaRekanan();

				kartuStokService.saveKartuStok(pphpService.konversiKali(p.getId(), satuanAsal.getId(), satuanTujuan.getId(),
						penerimaanBarangDetailVO.getJumlahTerima()), p, r, keterangan, true, new Date());
				listStrukPelayananDetail.add(strukPelayananDetail);
			}
			noVerifikasi(listStrukPelayananDetail);// add by Arya
		}		
		strukPelayananDao.save(strukPelayanan);
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("noRec", strukPelayanan.getNoRec());

		return result;

	}

	// add by Arya 2017-03-15
	private Map<String, Object> noVerifikasi(List<StrukPelayananDetail> listStrukPelayananDetail) {

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

		try {
			System.out.println("=======START SAVE STRUK VERIFIKASI PENERIMAAN SUPPLIER=======");

			String[] a = GetSettingDataFixed("RuanganVerifikasiPembayaranHutang").split(",");
			String b = GetSettingDataFixed("KdRuanganAkuntansi");

			List<Map<String, Object>> map = strukPelayananDao.getRuanganVerifikasiPembayaranHutang();
			String[] ruanganSplit = map.get(0).get("nilaiField").toString().split(",");

			Set<StrukVerifikasi> list = new HashSet<>();
			StrukVerifikasi strukVerifikasi = new StrukVerifikasi();

			String tempString = "";

			for (int i = 0; i < a.length; i++) {
				StrukVerifikasi strukVerif = new StrukVerifikasi();
				strukVerif.setNoUrutRuangan((i + 1) + "");
				strukVerif.setKelompokTransaksi(kelompokTransaksiDao
						.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPenerimaanBarangLogistik"))));
				strukVerif.setTglverifikasi(DateUtil.getShortDate());
				strukVerifikasi.setTglverifikasi(DateUtil.getShortDate());
				strukVerifikasi.setKelompokTransaksi(kelompokTransaksiDao
						.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPenerimaanBarangLogistik"))));

				final List<String> temp = new ArrayList<String>();
				Collections.addAll(temp, ruanganSplit);
				temp.remove(tempString);
				ruanganSplit = temp.toArray(new String[temp.size()]);

				for (String idRuangan : ruanganSplit) {
					Ruangan ruangan = new Ruangan();
					ruangan.setId(Integer.parseInt(idRuangan));
					strukVerif.setRuangan(ruangan);
					if (idRuangan.equals("61") && b.equals("61")) {
						strukVerif.setNoverifikasi("VA" + generateNoVerifikasi());
						list.add(strukVerif);
						tempString = idRuangan;
						break;
					} else {
						strukVerif.setNoverifikasi("VO" + generateNoVerifikasi());
						list.add(strukVerif);
						tempString = idRuangan;
						break;
					}
				}
				strukVerifikasi.setStrukVerifikasiSet(list);
				for(StrukPelayananDetail strukPelayananDetail : listStrukPelayananDetail)
				{
					strukPelayananDetail.setStrukVerifikasi(strukVerifikasi);
				}	
				if (CommonUtil.isNotNullOrEmpty(strukVerif)) {
					strukVerif.setStrukVerifikasi(strukVerifikasi);
				}
			}

			StrukVerifikasi model = strukVerifikasiDao.save(strukVerifikasi);
			result.put("noRecStrukVerifikasi", model.getNoRec());

			System.out.println("=======END SAVE STRUK VERIFIKASI PENERIMAAN SUPPLIER=======");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	private void updateStok(StrukPelayananDetail strukPelayananDetail) {
		updateStokGlobal(strukPelayananDetail);
		updateHargaJual(strukPelayananDetail);

	}

	// Initiaize HargaNettoProdukByTerima
	private HargaNettoProdukByTerima initializeHargaNettoProdukByTerima(StrukPelayananDetail strukPelayananDetail) {
		Double persenPpn = 0.0;
		Double persenDiskon = 0.0;
		Double ppn = 0.0;
		Double diskon = 0.0;
		Double hargaSatuan = 0.0;

		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getPersenppn())) {
			persenPpn = strukPelayananDetail.getPersenppn();
		}
		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getPersendiscount())) {
			persenDiskon = strukPelayananDetail.getPersendiscount();
		}

		if (CommonUtil.isNotNullOrEmpty(strukPelayananDetail.getHargasatuan())) {
			hargaSatuan = strukPelayananDetail.getHargasatuan();
		}

		ppn = ((persenDiskon / hargaSatuan) * 100);
		diskon = ((persenPpn / hargaSatuan) * 100);
		Double hargaNetto1 = hargaSatuan + ppn;
		Double hargaNetto2 = hargaNetto1 - diskon;
		HargaNettoProdukByTerima hargaNettoProdukByTerima = new HargaNettoProdukByTerima();

		hargaNettoProdukByTerima.setAsalProduk(strukPelayananDetail.getKdasalproduk());
		hargaNettoProdukByTerima.setFactorRate(0.0);
		hargaNettoProdukByTerima.setHargaDiscount(diskon);
		hargaNettoProdukByTerima.setHargaNetto1(hargaNetto1);
		hargaNettoProdukByTerima.setHargaNetto2(hargaNetto2);
		hargaNettoProdukByTerima.setHargaSatuan(hargaSatuan);
		hargaNettoProdukByTerima.setKdProfile((short) 0);

		hargaNettoProdukByTerima.setNoStrukTerima(strukPelayananDetail.getNostruk());
		hargaNettoProdukByTerima.setPersenDiscount(strukPelayananDetail.getPersendiscount());
		hargaNettoProdukByTerima.setProduk(strukPelayananDetail.getKdproduk());
		hargaNettoProdukByTerima.setQtyProduk(strukPelayananDetail.getHasilKonversi());
		hargaNettoProdukByTerima.setQtyProdukOutExt(0.0);
		hargaNettoProdukByTerima.setStatusEnabled(true);
		hargaNettoProdukByTerima.setTglKadaluarsaLast(strukPelayananDetail.getTglKadaluarsa());

		return hargaNettoProdukByTerima;

	}

	// update stok Produk Global
	public void updateStokGlobal(StrukPelayananDetail detail) {
		// updateuntuk Stok Produk Global
		Double persenPpn = 0.0;
		Double persenDiskon = 0.0;
		Double ppn = 0.0;
		Double diskon = 0.0;
		Double hargaSatuan = 0.0;

		if (CommonUtil.isNotNullOrEmpty(detail.getPersenppn())) {
			persenPpn = detail.getPersenppn();
		}
		if (CommonUtil.isNotNullOrEmpty(detail.getPersendiscount())) {
			persenDiskon = detail.getPersendiscount();
		}

		if (CommonUtil.isNotNullOrEmpty(detail.getHargasatuan())) {
			hargaSatuan = detail.getHargasatuan();
		}

		ppn = ((persenDiskon / hargaSatuan) * 100);
		diskon = ((persenPpn / hargaSatuan) * 100);
		Double hargaNetto1 = hargaSatuan + ppn;
		Double hargaNetto2 = hargaNetto1 - diskon;
		if (CommonUtil.isNotNullOrEmpty(detail.getKdproduk())
				&& CommonUtil.isNotNullOrEmpty(detail.getKdasalproduk())) {
			List<StokProdukGlobal> listStokProdukGlobal = stokProdukGlobalDao
					.findStokWitAsalProduk(detail.getKdproduk().getId(), new Integer(GetSettingDataFixed(
							"kdRuanganLogistik"))/*
													 * ,detail.getKdasalproduk()
													 * . getId()
													 */);
			if (CommonUtil.isNotNullOrEmpty(listStokProdukGlobal)) {
				StokProdukGlobal stokProdukGlobal = listStokProdukGlobal.get(0);
				stokProdukGlobal.setQtyProduk(stokProdukGlobal.getQtyProduk() + detail.getHasilKonversi());
				stokProdukGlobal.setAsalProduk(detail.getKdasalproduk());
				stokProdukGlobal.setHargaDiscount(diskon);
				stokProdukGlobal.setHargaNetto1(hargaNetto1);
				stokProdukGlobal.setHargaNetto2(hargaNetto2);
				stokProdukGlobal.setPersenDiscount(detail.getPersendiscount());
				stokProdukGlobal.setNamaExternal(detail.getKdproduk().getNamaProduk());
				stokProdukGlobal.setKodeExternal("0");
				stokProdukGlobal.setReportDisplay(detail.getKdproduk().getNamaProduk());
				stokProdukGlobalDao.save(stokProdukGlobal);
			} else {
				StokProdukGlobal stokProdukGlobal = new StokProdukGlobal();
				stokProdukGlobal.setQtyProdukOnHand(new Double(0));
				stokProdukGlobal.setQtyProdukMin(new Double(0));
				stokProdukGlobal.setQtyProdukMax(new Double(0));
				stokProdukGlobal.setQtyProduk(detail.getHasilKonversi());
				stokProdukGlobal.setAsalProduk(detail.getKdasalproduk());
				stokProdukGlobal.setHargaDiscount(diskon);
				stokProdukGlobal.setHargaNetto1(hargaNetto1);
				stokProdukGlobal.setHargaNetto2(hargaNetto2);
				stokProdukGlobal.setPersenDiscount(detail.getPersendiscount());
				stokProdukGlobal.setProduk(detail.getKdproduk());
				stokProdukGlobal.setRuangan(ruanganDao.findById(new Integer(GetSettingDataFixed("kdRuanganLogistik"))));
				stokProdukGlobal.setNamaExternal(detail.getKdproduk().getNamaProduk());
				stokProdukGlobal.setKodeExternal("0");
				stokProdukGlobal.setReportDisplay(detail.getKdproduk().getNamaProduk());
				stokProdukGlobalDao.save(stokProdukGlobal);
			}

		}

	}

	public Set<StokProdukDetail> initializeStokProdukDetail(Set<DetilPenerimaanVO> detilPenerimaan,
			StrukPelayananDetail detail) {
		Set<StokProdukDetail> setStokprodukDetail = new HashSet<StokProdukDetail>();
		for (DetilPenerimaanVO vo : detilPenerimaan) {

			// updateuntuk Stok Produk Global
			Double persenPpn = 0.0;
			Double persenDiskon = 0.0;
			Double ppn = 0.0;
			Double diskon = 0.0;
			Double hargaSatuan = 0.0;

			if (CommonUtil.isNotNullOrEmpty(detail.getPersenppn())) {
				persenPpn = detail.getPersenppn();
			}
			if (CommonUtil.isNotNullOrEmpty(detail.getPersendiscount())) {
				persenDiskon = detail.getPersendiscount();
			}

			if (CommonUtil.isNotNullOrEmpty(detail.getHargasatuan())) {
				hargaSatuan = detail.getHargasatuan();
			}

			ppn = ((persenDiskon / hargaSatuan) * 100);
			diskon = ((persenPpn / hargaSatuan) * 100);
			Double hargaNetto1 = hargaSatuan + ppn;
			Double hargaNetto2 = hargaNetto1 - diskon;
			StrukPelayanan strukPelayanan = detail.getNostruk();
			StokProdukDetail stokProdukDetail = new StokProdukDetail();
			stokProdukDetail.setQtyProdukOnHand(new Double(0));
			stokProdukDetail.setQtyProdukOutInt(0.0);
			stokProdukDetail.setQtyProdukOutExt(0.0);
			stokProdukDetail.setQtyProduk(vo.getQty());
			if (CommonUtil.isNotNullOrEmpty(detail.getKdproduk())) {
				Byte isRegisterAsset = produkDao.isRegisterAset(detail.getKdproduk().getId());
				if (isRegisterAsset == 0) {
					stokProdukDetail.setTglkadaluarsa(vo.getTanggalKadaluarsa());
				} else {
					stokProdukDetail.setTglproduksi(vo.getTanggalKadaluarsa());
				}
			}
			stokProdukDetail.setTglpelayanan(new Date());
			stokProdukDetail.setNobatch(vo.getNoBatch());
			stokProdukDetail.setStrukPelayanan(strukPelayanan);
			stokProdukDetail.setAsalProduk(detail.getKdasalproduk());
			stokProdukDetail.setHargaDiscount(diskon);
			stokProdukDetail.setHargaNetto1(hargaNetto1);
			stokProdukDetail.setHargaNetto2(hargaNetto2);
			stokProdukDetail.setPersenDiscount(detail.getPersendiscount());
			stokProdukDetail.setProduk(detail.getKdproduk());
			stokProdukDetail.setRuangan(ruanganDao.findById(new Integer(GetSettingDataFixed("kdRuanganLogistik"))));

			setStokprodukDetail.add(stokProdukDetail);

		}
		return setStokprodukDetail;
	}

	// Qty Produk Akan Diupdate Ketika Setting di jenis trasaksi Nilai
	// metodeHargaNetto 3/4 atau hargaAverage/hargaTertinggi
	public void updateHargaJual(StrukPelayananDetail detail) {
		Map<String, Object> dataJenisTransaksi = jenisTransaksiDao.metodePenenntuanHarga(detail.getObjectProdukId());
		if (CommonUtil.isNotNullOrEmpty(dataJenisTransaksi)) {
			// fifo
			List<StokProdukGlobal> listStokProdukGlobal = stokProdukGlobalDao.findStokWitAsalProduk(
					detail.getKdproduk().getId(),
					new Integer(GetSettingDataFixed("kdRuanganLogistik"))/* , null */);
			if (CommonUtil.isNotNullOrEmpty(listStokProdukGlobal)) {
				StokProdukGlobal stokProdukGlobal = listStokProdukGlobal.get(0);

				// fifo
				if (dataJenisTransaksi.get("metodeHargaNetto").equals(1)) {

				}

				// fefo
				if (dataJenisTransaksi.get("metodeHargaNetto").equals(2)) {

				}

				// average
				if (dataJenisTransaksi.get("metodeHargaNetto").equals(3)) {

				}

				// tertinggi
				if (dataJenisTransaksi.get("metodeHargaNetto").equals(4)) {

				}

				stokProdukGlobalDao.save(stokProdukGlobal);
			}
		}
	}

	public Set<RegistrasiAset> registrasiAsset(PenerimaanBarangDetailVO penerimaanBarangDetailVO,
			StrukPelayanan strukPelayanan, StrukPelayananDetail detail) {
		Set<RegistrasiAset> result = new HashSet<RegistrasiAset>();
		Produk p = produkDao.findOne(penerimaanBarangDetailVO.getProduk().getId());
		if (CommonUtil.isNotNullOrEmpty(p)) {
			if (CommonUtil.isNotNullOrEmpty(p.getDetailJenisProduk())) {
				if (CommonUtil.isNotNullOrEmpty(p.getDetailJenisProduk().getIsRegistrasiAset())) {
					if (p.getDetailJenisProduk().getIsRegistrasiAset() == 1) {
						if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getJumlahTerima())) {
							Integer jumlahTerima = penerimaanBarangDetailVO.getJumlahTerima().intValue();
							Integer count = registrasiAsetDao.countRegistrasiAset();
							for (Integer a = 1; a <= jumlahTerima; a++) {
								RegistrasiAset registrasiAset = new RegistrasiAset();
								if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getProduk())) {
									registrasiAset.setProduk(produkConverter
											.transferVOToModel(penerimaanBarangDetailVO.getProduk(), new Produk()));
								}

								if (CommonUtil.isNotNullOrEmpty(penerimaanBarangDetailVO.getAsalProduk())) {
									registrasiAset.setAsalProduk(asalProdukConverter.transferVOToModel(
											penerimaanBarangDetailVO.getAsalProduk(), new AsalProduk()));
								}
								registrasiAset.setHargaNetto(0.00);
								registrasiAset.setHargaSatuanRevaluasi(0.00);
								registrasiAset.setUmurEkonomisRevaluasiTahun(0.00);
								registrasiAset.setTotalSisaUmurEkonomisTahun(0.00);
								registrasiAset
										.setNoRegisterAset(generateNoRegisterAset() + getRunningNumber("No Aset"));
								registrasiAset.setStrukPelayananDetail(detail);
								registrasiAset.setStrukPelayanan(strukPelayanan);
								registrasiAset.setTglRegisterAset(strukPelayanan.getTglterimakiriman());
								registrasiAset.setProduk(p);
								registrasiAset.setRuangan(getRuanganByUserLogin());
								result.add(registrasiAset);
							}
						}
					}
				}
			}
		}

		return result;
	}

	@Transactional(readOnly = false)
	public String generateNoRegisterAset() {
		Date dateNow = new Date();
		Integer month = DateUtil.getMonthFromDate(dateNow);
		Integer year = DateUtil.getYearFromDate(dateNow);

		String monthNow = month.toString();
		String yearNow = year.toString().substring(2, 4);

		return yearNow + monthNow;
	}

	public String generateNoVerifikasi() {

		Date dateNow = new Date();
		Integer month = DateUtil.getMonthFromDate(dateNow);
		Integer year = DateUtil.getYearFromDate(dateNow);
		Long count = strukVerifikasiDao.count();

		String monthNow = month.toString();
		String yearNow = year.toString().substring(2, 4);
		String noSbk = null;

		count++;
		if (count.toString().length() == 1) {
			noSbk = "000000";
		} else if (count.toString().length() == 2) {
			noSbk = "000000";
		} else if (count.toString().length() == 3) {
			noSbk = "000000";
		} else if (count.toString().length() == 4) {
			noSbk = "000000";
		} else if (count.toString().length() == 5) {
			noSbk = "000000";
		} else if (count.toString().length() == 6) {
			noSbk = "000000";
		}
		if (monthNow.length() == 1)
			monthNow = "0" + monthNow;

		return yearNow + monthNow + noSbk + count;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveKirimPesananBarang(KirimPesananBarangVO vo) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setTglstruk(new Date());
		strukPelayanan.setNostruk(getRunningNumber("StrukPelayanan"));
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPengirimanBarangLogistik"))));
		if (CommonUtil.isNotNullOrEmpty(vo.getStrukOrder())) {
			strukPelayanan.setNoorder(strukOrderConverter.transferVOToModel(vo.getStrukOrder(), new StrukOrder()));
		}
		if (CommonUtil.isNotNullOrEmpty(vo.getKirimPesananBarangDetail())) {
			for (KirimPesananBarangDetailVO kirimPesananBarangDetailVO : vo.getKirimPesananBarangDetail()) {
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				strukPelayananDetail.setQtyproduk(kirimPesananBarangDetailVO.getKirim());
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscountgive(0.0);
				strukPelayananDetail.setHargadiscountsave(0.0);
				strukPelayananDetail.setHarganetto(0.0);
				strukPelayananDetail.setHargapph(0.0);
				strukPelayananDetail.setHargappn(0.0);
				strukPelayananDetail.setHargasatuandijamin(0.0);
				strukPelayananDetail.setHargasatuanppenjamin(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setQtyorang((byte) 0);
				strukPelayananDetail.setIsonsiteservice((byte) 0);
				strukPelayananDetail.setQtyprodukoutext(0.0);
				strukPelayananDetail.setQtyprodukoutint(0.0);
				strukPelayananDetail.setQtyprodukretur(0.0);
				strukPelayananDetail.setSatuan("");
				strukPelayananDetail.setTglpelayanan(strukPelayanan.getTglstruk());
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail.setPersendiscount(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);

				if (CommonUtil.isNotNullOrEmpty(kirimPesananBarangDetailVO.getProduk())) {
					strukPelayananDetail.setKdproduk(
							produkConverter.transferVOToModel(kirimPesananBarangDetailVO.getProduk(), new Produk()));
				}
				if (CommonUtil.isNotNullOrEmpty(kirimPesananBarangDetailVO.getAsalProduk())) {
					strukPelayananDetail.setKdasalproduk(asalProdukConverter
							.transferVOToModel(kirimPesananBarangDetailVO.getAsalProduk(), new AsalProduk()));
				}
				if (CommonUtil.isNotNullOrEmpty(kirimPesananBarangDetailVO.getSatuanKirim())) {
					strukPelayananDetail.setKdsatuanstandar(satuanStandarConverter
							.transferVOToModel(kirimPesananBarangDetailVO.getSatuanKirim(), new SatuanStandar()));
				}
				strukPelayanan.getStrukPelayananDetail().add(strukPelayananDetail);
			}
		}
		strukPelayananDao.save(strukPelayanan);
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("noRec", strukPelayanan.getNoRec());
		return result;

	}

	@Override
	public Map<String, Object> saveNoBatch(InputNoBatchVO vo) {
		Map<String, Object> result = new HashMap<String, Object>();
		StrukPelayananDetail detail = strukPelayananDetailDao.findByNorec(vo.getStrukPelayananDetail());
		List<String> tmp = new ArrayList<String>();
		for (StrukPelayananDNoBatchVO modelVo : vo.getStrukPelayananDNoBatch()) {
			if (CommonUtil.isNotNullOrEmpty(detail)) {
				StrukPelayananDNoBatch modelEntity = new StrukPelayananDNoBatch();
				modelEntity.setKdasalproduk(detail.getKdasalproduk());
				modelEntity.setKdproduk(detail.getKdproduk());
				modelEntity.setKdruangan(ruanganDao.findById(new Integer(GetSettingDataFixed("kdRuanganLogistik"))));
				modelEntity.setKeteranganlainnya(modelVo.getKeteranganlainnya());
				modelEntity.setNobatch(modelVo.getNobatch());
				modelEntity.setTglpelayanan(modelVo.getTglpelayanan());
				modelEntity.setQtyproduk(modelVo.getQtyproduk());
				modelEntity.setQtyprodukoutint(0.0);
				modelEntity.setQtyprodukoutext(0.0);
				modelEntity.setVolumen(0.0);
				modelEntity.setTglkadaluarsa(modelVo.getTglkadaluarsa());
				modelEntity.setNostruk(detail);
				modelEntity = strukPelayananDNoBatchDao.save(modelEntity);
				tmp.add(modelEntity.getNoRec());
			}
		}
		result.put("result", tmp);
		return result;
	}

	@Override
	public Map<String, Object> savePemakaianBarangHabisPakai(PemakaianBarangHabisPakaiVO vo) {
		StrukPelayanan strukPelayanan = new StrukPelayanan();
		strukPelayanan.setTglterimakiriman(vo.getTanggalTerima());
		strukPelayanan.setKdruangan(getRuanganByUserLogin());
		strukPelayanan.setKeteranganlainnya(vo.getKeterangan());
		strukPelayanan.setTglstruk(vo.getTanggalTerima());
		strukPelayanan.setKdkelompoktransaksi(kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdKelompokPemakaianBarangHabisPakai"))));

		if (CommonUtil.isNotNullOrEmpty(vo.getPemakaianBarangHabisPakai())) {
			for (PemakaianBarangHabisPakaiDetailVO detailVo : vo.getPemakaianBarangHabisPakai()) {
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				strukPelayananDetail.setQtyproduk(detailVo.getQtyproduk());
				strukPelayananDetail.setHasilKonversi(detailVo.getQtyproduk());
				strukPelayananDetail.setTglKadaluarsa(null);
				strukPelayananDetail.setNobatch(null);
				strukPelayananDetail.setHargasatuan(0.0);
				strukPelayananDetail.setPersendiscount(0.0);
				strukPelayananDetail.setNostruk(strukPelayanan);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscount(0.0);
				strukPelayananDetail.setHargadiscountgive(0.0);
				strukPelayananDetail.setHargadiscountsave(0.0);
				strukPelayananDetail.setHarganetto(0.0);
				strukPelayananDetail.setHargapph(0.0);
				strukPelayananDetail.setHargappn(0.0);
				strukPelayananDetail.setHargasatuandijamin(0.0);
				strukPelayananDetail.setHargasatuanppenjamin(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setHargatambahan(0.0);
				strukPelayananDetail.setQtyorang((byte) 0);
				strukPelayananDetail.setIsonsiteservice((byte) 0);
				strukPelayananDetail.setQtyprodukoutext(0.0);
				strukPelayananDetail.setQtyprodukoutint(0.0);
				strukPelayananDetail.setQtyprodukretur(0.0);
				strukPelayananDetail.setSatuan("");
				strukPelayananDetail.setTglpelayanan(strukPelayanan.getTglstruk());

				strukPelayananDetail.setHargasatuanpprofile(0.0);
				strukPelayananDetail.setHargasatuanpprofile(0.0);

				if (CommonUtil.isNotNullOrEmpty(detailVo.getProduk())) {
					strukPelayananDetail
							.setKdproduk(produkConverter.transferVOToModel(detailVo.getProduk(), new Produk()));
				}

				if (CommonUtil.isNotNullOrEmpty(detailVo.getSatuan())) {
					strukPelayananDetail.setKdsatuanstandar(
							satuanStandarConverter.transferVOToModel(detailVo.getSatuan(), new SatuanStandar()));
				}
				strukPelayanan.getStrukPelayananDetail().add(strukPelayananDetail);

				Produk p = produkDao.findByIdProduk(detailVo.getProduk().getId());
				Integer satuanTujuan = detailVo.getSatuan().getId();
				Integer satuanAsal = null;

				if (CommonUtil.isNotNullOrEmpty(p.getSatuanStandar())) {
					satuanAsal = p.getSatuanStandar().getId();
				}
				Ruangan r = getRuanganByUserLogin();

				Double hasilKon = pphpService.konversiKali(p.getId(), satuanAsal, satuanTujuan, detailVo.getQtyproduk());
				kartuStokService.saveKartuStok(hasilKon, p, r, "Pemakaian Barang Habis Pakai", false, new Date());
				// update Stok Produk Detail
				stokProdukGlobalService.updateStokProdukDetailPemusnahanBarang(p.getId(), getRuanganByUserLogin(),
						hasilKon, strukPelayanan);
				// Upate Stok Produk Global
				stokProdukGlobalService.updateStokPemusnahanBarang(p, hasilKon, getRuanganByUserLogin());

			}
		}
		strukPelayananDao.save(strukPelayanan);
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("noRec", strukPelayanan.getNoRec());

		return result;

	}

	// Paging List Untuk Kartu Pengendalai
	@Override
	public Map<String, Object> listPemakaian(Integer page, Integer limit, String sort, String dir, String tanggalAwal,
			String tanggalAhir, Integer kelompokProdukId, Integer jenisProdukId, Integer produkId) {
		Integer ruanganId = getRuanganByUserLogin().getId();
		Integer kelompokTransaksiId = kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdKelompokPemakaianBarangHabisPakai")))
				.getId();
		int totalRow = strukPelayananDetailDaoCustom.listPemakaianBarangHabisPakaiCount(tanggalAwal, tanggalAhir,
				kelompokProdukId, jenisProdukId, produkId, ruanganId, kelompokTransaksiId);
		int totalPages = 0;
		int pageRequested = page;

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

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data", strukPelayananDetailDaoCustom.listPemakaianBarangHabisPakai(rowStart, rowEnd, sort, dir,
				tanggalAwal, tanggalAhir, kelompokProdukId, jenisProdukId, produkId, ruanganId, kelompokTransaksiId));
		result.put("totalPages", totalPages);
		result.put("totalRow", totalRow);
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> listPenerimaanBarang(Integer page, Integer limit, String sort, String dir,
			String tanggalAwal, String tanggalAhir, Integer produkId, Integer jenisProdukId, Integer kelompokProdukId,
			String noTerima) {
		Integer ruanganId = getRuanganByUserLogin().getId();
		Integer kelompokTransaksiId = kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPenerimaanBarangLogistik"))).getId();
		int totalRow = strukPelayananDetailDaoCustom.listPenerimaanCountSupplier(tanggalAwal, tanggalAhir, produkId,
				ruanganId, kelompokTransaksiId, jenisProdukId, kelompokProdukId, noTerima);
		int totalPages = 0;
		int pageRequested = page;

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

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data",
				strukPelayananDetailDaoCustom.listPenerimaanSupplier(rowStart, rowEnd, sort, dir, tanggalAwal,
						tanggalAhir, produkId, ruanganId, kelompokTransaksiId, jenisProdukId, kelompokProdukId,
						noTerima));
		result.put("totalPages", totalPages);
		result.put("totalRow", totalRow);
		return result;
	}

	@Override
	public Map<String, Object> getDetailPenerimaanBarang(String noRec) {
		Map<String, Object> data = new HashMap<String, Object>();
		data.put("header", strukPelayananDetailDaoCustom.findPenerimaanHeaderByNoRec(noRec));
		List<Map<String, Object>> tmp = new ArrayList<Map<String, Object>>();
		for (Map<String, Object> detail : strukPelayananDetailDaoCustom.findPenerimaanDetailByNoRec(noRec)) {
			if (CommonUtil.isNotNullOrEmpty(detail.get("noRecDetail"))) {
				Double sisa = strukPelayananDetailDaoCustom.findSumRetur((String) detail.get("noRecDetail"));
				if (CommonUtil.isNotNullOrEmpty(sisa)) {
					detail.remove("qtyProduk");
					detail.put("qtyProduk", sisa);
				}

				tmp.add(detail);
			}
		}
		data.put("detail", tmp);
		return data;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> saveReturSupplier(ReturSupplierVO vo) {
		StrukRetur strukRetur = new StrukRetur();
		strukRetur.setTglRetur(vo.getTanggalRetur());
		strukRetur.setRuangan(getRuanganByUserLogin());
		String noUrut = strukOrderService.formatNoUrut("Struk Retur", "RRS");
		strukRetur.setNoRetur(noUrut);
		strukRetur.setPegawai(getPegawaiByUserLogin());
		strukRetur.setKeteranganAlasan(vo.getKeterangan());
		KelompokTransaksi kelompokTransaksi = kelompokTransaksiDao
				.findById(Integer.parseInt(GetSettingDataFixed("KdKelompokReturSupplier")));
		strukRetur.setKelompokTransaksi(kelompokTransaksi);
		List<StrukPelayananDetail> data = new ArrayList<StrukPelayananDetail>();
		if (CommonUtil.isNotNullOrEmpty(vo.getReturDetail())) {
			for (ReturSupplierDetailVO returSuppier : vo.getReturDetail()) {
				StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
				StrukPelayananDetail entity = new StrukPelayananDetail();
				strukPelayananDetail.setNoretur(strukRetur);
				if (CommonUtil.isNotNullOrEmpty(returSuppier.getDetail())) {
					entity = strukPelayananDetailDao.findByNoRec(returSuppier.getDetail().getNoRec());
				}
				if (CommonUtil.isNotNullOrEmpty(entity)) {
					strukPelayananDetail.setQtyproduk(returSuppier.getQtyProdukRetur());
					strukPelayananDetail.setHasilKonversi(returSuppier.getQtyProdukRetur());
					strukPelayananDetail.setTglKadaluarsa(entity.getTglKadaluarsa());
					strukPelayananDetail.setNobatch(entity.getNobatch());
					strukPelayananDetail.setHargasatuan(entity.getHargasatuan());
					strukPelayananDetail.setPersendiscount(entity.getPersendiscount());
					strukPelayananDetail.setNostruk(entity.getNostruk());
					strukPelayananDetail.setHargadiscount(entity.getHargadiscount());
					strukPelayananDetail.setHargadiscountgive(entity.getHargadiscountgive());
					strukPelayananDetail.setHargadiscountsave(entity.getHargadiscountsave());
					strukPelayananDetail.setHarganetto(entity.getHarganetto());
					strukPelayananDetail.setHargapph(entity.getHargapph());
					strukPelayananDetail.setHargappn(entity.getHargappn());
					strukPelayananDetail.setHargasatuandijamin(entity.getHargasatuandijamin());
					strukPelayananDetail.setHargasatuanppenjamin(entity.getHargasatuandijamin());
					strukPelayananDetail.setHargasatuanpprofile(entity.getHargasatuanpprofile());
					strukPelayananDetail.setHargatambahan(entity.getHargatambahan());
					strukPelayananDetail.setQtyorang(entity.getQtyorang());
					strukPelayananDetail.setIsonsiteservice(entity.getIsonsiteservice());
					strukPelayananDetail.setQtyprodukoutext(entity.getQtyprodukoutext());
					strukPelayananDetail.setQtyprodukoutint(entity.getQtyprodukoutint());
					strukPelayananDetail.setQtyprodukretur(entity.getQtyprodukretur());
					strukPelayananDetail.setSatuan(entity.getSatuan());
					strukPelayananDetail.setTglpelayanan(entity.getNostruk().getTglstruk());
					strukPelayananDetail.setKdasalproduk(entity.getKdasalproduk());
					strukPelayananDetail.setHargasatuanpprofile(0.0);
					strukPelayananDetail.setHargasatuanpprofile(0.0);
					strukPelayananDetail.setStrukPelayananDetail(entity);

					strukPelayananDetail.setKdproduk(entity.getKdproduk());

					strukPelayananDetail.setKdsatuanstandar(entity.getKdsatuanstandar());
					data.add(strukPelayananDetail);

					// update stok Produk Global &stok Produk Detail
					// updateStok(strukPelayananDetail);

					Produk p = produkDao.findByIdProduk(entity.getKdproduk().getId());
					Integer satuanTujuan = entity.getKdsatuanstandar().getId();
					Integer satuanAsal = null;

					if (CommonUtil.isNotNullOrEmpty(p.getSatuanStandar())) {
						satuanAsal = p.getSatuanStandar().getId();
					}
					Ruangan r = getRuanganByUserLogin();
					Double hasilKon = pphpService.konversiKali(p.getId(), satuanAsal, satuanTujuan,
							returSuppier.getQtyProdukRetur());
					kartuStokService.saveKartuStok(hasilKon, p, r, "Retur Supplier", false, new Date());
					// update Stok Produk Detail
					stokProdukGlobalService.updateStokProdukDetailPemusnahanBarang(p.getId(), getRuanganByUserLogin(),
							hasilKon, entity.getNostruk());
					// Upate Stok Produk Global
					stokProdukGlobalService.updateStokPemusnahanBarang(p, hasilKon, getRuanganByUserLogin());
				}
			}
			strukRetur.getStrukPelayananDetail().clear();
			strukRetur.getStrukPelayananDetail().addAll(data);

			strukRetur = strukReturDao.save(strukRetur);

		}
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("noRec", strukRetur.getNoRec());

		return result;
	}

	@Override
	public Map<String, Object> listReturSupplier(Integer page, Integer limit, String sort, String dir,
			String tanggalAwal, String tanggalAhir, Integer produkId, Integer jenisProdukId, Integer kelompokProdukId,
			Integer supplierId) {
		Integer kelompokTransaksi = Integer.parseInt(GetSettingDataFixed("KdKelompokReturSupplier"));
		int totalRow = strukPelayananDetailDaoCustom.listReturSupplierCount(tanggalAwal, tanggalAhir, produkId,
				jenisProdukId, kelompokProdukId, supplierId, kelompokTransaksi);
		int totalPages = 0;
		int pageRequested = page;

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

		if (pageRequested > totalPages)
			pageRequested = totalPages;
		int rowStart = pageRequested * limit - limit;
		if (rowStart < 0) {
			rowStart = 0;
		}
		int rowEnd = limit;
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data", strukPelayananDetailDaoCustom.listReturSupplierList(rowStart, rowEnd, sort, dir, tanggalAwal,
				tanggalAhir, produkId, jenisProdukId, kelompokProdukId, supplierId, kelompokTransaksi));
		result.put("totalPages", totalPages);
		result.put("totalRow", totalRow);
		return result;
	}

	@Override
	@Transactional(readOnly = false)
	public Map<String, Object> uploadExel(UploadExcelVO vo) throws IOException {

		byte[] decodedBytes = Base64.decodeBase64(vo.getFileInput());
		String targetFile = reportDirectory + UUID.randomUUID().toString().replaceAll("-", "") + ".xls";
		writeByteArraysToFile(targetFile, decodedBytes);

		List<StrukPelayananDetail> listBooks = new ArrayList<StrukPelayananDetail>();
		try {

			StrukPelayanan strukPelayanan = new StrukPelayanan();
			strukPelayanan.setTglterimakiriman(vo.getTanggalTerima());
			strukPelayanan.setNofaktur(vo.getNoFaktur());
			strukPelayanan.setNostruk(getRunningNumber("Penerimaan Supplier"));
			strukPelayanan.setTglfaktur(vo.getTanggalFaktur());
			if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
				strukPelayanan.setKdruanganasal(ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
			}
			strukPelayanan.setTgljatuhtempo(vo.getTanggalJatuhTempo());
			strukPelayanan.setTotalbeamaterai(vo.getTotalBeaMaterai());
			strukPelayanan.setTglstruk(new Date());
			strukPelayanan.setKdkelompoktransaksi(kelompokTransaksiDao
					.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdPenerimaanBarangLogistik"))));
			if (CommonUtil.isNotNullOrEmpty(vo.getSupplier())) {
				strukPelayanan.setKdrekanan(rekananConverter.transferVOToModel(vo.getSupplier(), new Rekanan()));
			}

			FileInputStream file = new FileInputStream(new File(targetFile));

			// Get the workbook instance for XLS file
			HSSFWorkbook workbook = new HSSFWorkbook(file);

			// Get first sheet from the workbook
			HSSFSheet sheet = workbook.getSheetAt(0);

			// Iterate through each rows from first sheet
			Iterator<Row> rowIterator = sheet.iterator();
			int a = 5;
			while (rowIterator.hasNext()) {

				System.out.println("at  " + a);
				a++;
				Row row = rowIterator.next();
				if (row.getRowNum() == 0) {

				} else if (row.getRowNum() == 1) {

				} else if (row.getRowNum() == 2) {

				} else if (row.getRowNum() == 3) {

				} else {
					AsalProduk kdasalproduk = new AsalProduk();
					kdasalproduk.setId(1);
					Iterator<Cell> cellIterator = row.cellIterator();
					PenerimaanBarangDetailVO hps = new PenerimaanBarangDetailVO();
					StrukPelayananDetail strukPelayananDetail = new StrukPelayananDetail();
					StokProdukDetail stokProdukDetail = new StokProdukDetail();

					List<StokProdukDetail> stokProdukDetails = new ArrayList<StokProdukDetail>();
					while (cellIterator.hasNext()) {

						Cell nextCell = cellIterator.next();
						int columnIndex = nextCell.getColumnIndex();

						if (CommonUtil.isNotNullOrEmpty(getCellValue(nextCell))) {
							switch (columnIndex) {
							case 1:
								break;
							case 2:
								break;
							case 3:
								Produk p = new Produk();
								Double idProduk = (Double) getCellValue(nextCell);
								p.setId(idProduk.intValue());
								strukPelayananDetail.setKdproduk(p);
								break;
							case 4:
								// set Nama Produk
								break;
							case 5:
								// set qty produk
								strukPelayananDetail.setQtyproduk((Double) getCellValue(nextCell));
								stokProdukDetail.setQtyProduk((Double) getCellValue(nextCell));
								strukPelayananDetail.setHasilKonversi((Double) getCellValue(nextCell));
								break;
							case 6:
								// set qty produk
								SatuanStandar satuanStandar = new SatuanStandar();
								Double satuanStandarId = (Double) getCellValue(nextCell);
								satuanStandar.setId(satuanStandarId.intValue());
								strukPelayananDetail.setKdsatuanstandar(satuanStandar);
								break;
							case 7:
								SatuanStandar satuanStandar2 = new SatuanStandar();
								Double satuanStandarId2 = (Double) getCellValue(nextCell);
								satuanStandar2.setId(satuanStandarId2.intValue());
								strukPelayananDetail.setKdsatuanstandar(satuanStandar2);
								break;
							case 8:
								strukPelayananDetail.setHargasatuan((Double) getCellValue(nextCell));
								strukPelayananDetail.setHarganetto((Double) getCellValue(nextCell));
								stokProdukDetail.setHargaNetto1((Double) getCellValue(nextCell));
								stokProdukDetail.setHargaNetto2((Double) getCellValue(nextCell));
								break;
							case 9:
								stokProdukDetail.setPersenDiscount((Double) getCellValue(nextCell));
								break;
							case 10:
								stokProdukDetail.setNobatch((String) getCellValue(nextCell));
								break;
							case 11:
								SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
								String kalaluarsa = (String) getCellValue(nextCell);
								Date date = formatter.parse(kalaluarsa);
								stokProdukDetail.setTglkadaluarsa(date);

								break;
							case 12:
								SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd");
								String produksi = (String) getCellValue(nextCell);
								Date date2 = formatter2.parse(produksi);
								stokProdukDetail.setTglproduksi(date2);
								stokProdukDetail.setStrukPelayananDetail(strukPelayananDetail);
								stokProdukDetail.setAsalProduk(strukPelayananDetail.getKdasalproduk());
								stokProdukDetail.setHargaDiscount(strukPelayananDetail.getHargadiscount());
								stokProdukDetail.setProduk(strukPelayananDetail.getKdproduk());
								stokProdukDetail.setQtyProdukOnHand(new Double(0.0));
								stokProdukDetail.setQtyProdukOutInt(new Double(0.0));
								stokProdukDetail.setQtyProdukOutExt(new Double(0.0));
								stokProdukDetail.setTglpelayanan(new Date());
								stokProdukDetail.setAsalProduk(kdasalproduk);
								stokProdukDetail.setHargaDiscount(0.0);
								stokProdukDetail.setRuangan(ruanganDao.findById(vo.getRuangan().getId()));
								stokProdukDetail.setStatusEnabled(true);
								stokProdukDetail.setStrukPelayanan(strukPelayanan);
								if (CommonUtil.isNotNullOrEmpty(vo.getRuangan())) {
									stokProdukDetail.setRuangan(
											ruanganConverter.transferVOToModel(vo.getRuangan(), new Ruangan()));
									;
								}
								stokProdukDetails.add(stokProdukDetail);

								break;
							}
						}

					}

					strukPelayananDetail.setHargadiscount(0.0);
					strukPelayananDetail.setHargapph(0.0);
					strukPelayananDetail.setHargappn(0.0);
					strukPelayananDetail.setHargadiscountgive(0.0);
					strukPelayananDetail.setHargadiscountsave(0.0);
					strukPelayananDetail.setHargasatuandijamin(0.0);
					strukPelayananDetail.setHargasatuanppenjamin(0.0);
					strukPelayananDetail.setHargasatuanpprofile(0.0);
					strukPelayananDetail.setHargatambahan(0.0);
					strukPelayananDetail.setHargatambahan(0.0);
					strukPelayananDetail.setPersendiscount(0.0);
					strukPelayananDetail.setQtyorang((byte) 0);
					strukPelayananDetail.setIsonsiteservice((byte) 0);
					strukPelayananDetail.setQtyprodukoutext(0.0);
					strukPelayananDetail.setQtyprodukoutint(0.0);
					strukPelayananDetail.setQtyprodukretur(0.0);
					strukPelayananDetail.setSatuan("");
					strukPelayananDetail.setTglpelayanan(new Date());
					strukPelayananDetail.setNostruk(strukPelayanan);
					strukPelayananDetail.setHargasatuanpprofile(0.0);
					strukPelayananDetail.setHargasatuanpprofile(0.0);
					strukPelayananDetail.setKdasalproduk(kdasalproduk);
					strukPelayananDetail.getStokProdukDetail().addAll(stokProdukDetails);
					strukPelayanan.getHargaNettoProdukByTerima()
							.add(initializeHargaNettoProdukByTerima(strukPelayananDetail));
					listBooks.add(strukPelayananDetail);
					updateStok(strukPelayananDetail);

					Ruangan r = ruanganDao.findById(vo.getRuangan().getId());
					Rekanan rek = rekananDao.findOne(vo.getSupplier().getId());
					String keterangan = "Inisialisasi Produk ";
					Produk p = produkDao.findByIdProduk(strukPelayananDetail.getKdproduk().getId());
					kartuStokService.saveKartuStok(strukPelayananDetail.getQtyproduk(), p, r, keterangan, true,
							new Date());
				}

			}
			file.close();
			strukPelayanan.getStrukPelayananDetail().clear();
			strukPelayanan.getStrukPelayananDetail().addAll(listBooks);
			strukPelayanan = strukPelayananDao.save(strukPelayanan);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}

		Map<String, Object> r = new HashMap<String, Object>();
		r.put("data", "berhasil");
		return r;

	}

	public static void writeByteArraysToFile(String fileName, byte[] content) throws IOException {

		File file = new File(fileName);
		BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(file));
		writer.write(content);
		writer.flush();
		writer.close();

	}

	private Object getCellValue(Cell cell) {
		switch (cell.getCellType()) {
		case Cell.CELL_TYPE_STRING:
			return cell.getStringCellValue();

		case Cell.CELL_TYPE_BOOLEAN:
			return cell.getBooleanCellValue();

		case Cell.CELL_TYPE_NUMERIC:
			return cell.getNumericCellValue();
		}

		return null;
	}

	@Override
	public Map<String, Object> cetakListPemakaian(String tanggalAwal, String tanggalAhir, Integer kelompokProdukId,
			Integer jenisProdukId, Integer produkId) {
		Map<String, Object> result = new HashMap<String, Object>();
		Integer ruanganId = getRuanganByUserLogin().getId();
		Integer kelompokTransaksiId = kelompokTransaksiDao
				.findById(Integer.parseInt((String) this.GetSettingDataFixed("KdKelompokPemakaianBarangHabisPakai")))
				.getId();
		result.put("data", strukPelayananDetailDaoCustom.cetakListPemakaianBarangHabisPakai(tanggalAwal, tanggalAhir,
				kelompokProdukId, jenisProdukId, produkId, ruanganId, kelompokTransaksiId));

		Map<String, Object> header = new HashMap<String, Object>();
		header.put("tanggalAwal", tanggalAwal);
		header.put("tanggalAhir", tanggalAhir);
		if (CommonUtil.isNotNullOrEmpty(kelompokProdukId)) {
			header.put("kelompokProduk",
					kelompokProdukDao.findByKelompokProdukId(kelompokProdukId).get("kelompokProduk"));

		} else {
			header.put("kelompokProduk", "");
		}

		if (CommonUtil.isNotNullOrEmpty(kelompokProdukDao.findByJenisProdukId(jenisProdukId))) {
			header.put("jenisProduk", kelompokProdukDao.findByJenisProdukId(jenisProdukId).get("jenisProduk"));
		} else {
			header.put("jenisProduk", "");
		}

		header.put("ruangan", kelompokProdukDao.findByRuanganId(getRuanganByUserLogin().getId()).get("namaRuangan"));

		if (CommonUtil.isNotNullOrEmpty(produkId)) {
			header.put("produk", kelompokProdukDao.findByProdukId(produkId).get("namaProduk"));
		} else {
			header.put("produk", "");
		}
		result.put("header", header);

		return result;

	}

	@Override
	public Map<String, Object> cetakListReturSupplier(String tanggalAwal, String tanggalAhir, Integer produkId,
			Integer jenisProdukId, Integer kelompokProdukId, Integer supplierId) {
		Integer kelompokTransaksi = Integer.parseInt(GetSettingDataFixed("KdKelompokReturSupplier"));
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("data", strukPelayananDetailDaoCustom.cetakListReturSupplierList(tanggalAwal, tanggalAhir, produkId,
				jenisProdukId, kelompokProdukId, supplierId, kelompokTransaksi));

		Map<String, Object> header = new HashMap<String, Object>();
		header.put("tanggalAwal", tanggalAwal);
		header.put("tanggalAhir", tanggalAhir);
		if (CommonUtil.isNotNullOrEmpty(kelompokProdukId)) {
			header.put("kelompokProduk",
					kelompokProdukDao.findByKelompokProdukId(kelompokProdukId).get("kelompokProduk"));

		} else {
			header.put("kelompokProduk", "");
		}

		if (CommonUtil.isNotNullOrEmpty(kelompokProdukDao.findByJenisProdukId(jenisProdukId))) {
			header.put("jenisProduk", kelompokProdukDao.findByJenisProdukId(jenisProdukId).get("jenisProduk"));
		} else {
			header.put("jenisProduk", "");
		}

		header.put("ruangan", kelompokProdukDao.findByRuanganId(getRuanganByUserLogin().getId()).get("namaRuangan"));

		if (CommonUtil.isNotNullOrEmpty(produkId)) {
			header.put("produk", kelompokProdukDao.findByProdukId(produkId).get("namaProduk"));
		} else {
			header.put("produk", "");
		}
		result.put("header", header);

		return result;
	}
	
}
