diff --git a/ems-core/src/main/java/it/integry/ems_model/business_logic/dto/GeneraOrdLav.java b/ems-core/src/main/java/it/integry/ems_model/business_logic/dto/GeneraOrdLav.java new file mode 100644 index 0000000000..e490bab425 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems_model/business_logic/dto/GeneraOrdLav.java @@ -0,0 +1,1606 @@ +package it.integry.ems_model.business_logic.dto; + +import com.annimon.stream.Stream; +import it.integry.common.var.CommonConstants; +import it.integry.ems.rules.completing.ConfigActivityRules; +import it.integry.ems.rules.completing.DocOrdRules; +import it.integry.ems.rules.completing.OrderRules; +import it.integry.ems.rules.completing.dto.DatiPartitaMagDTO; +import it.integry.ems_model.base.EntityBase; +import it.integry.ems_model.business_logic.UtilityProduction; +import it.integry.ems_model.config.EmsRestConstants; +import it.integry.ems_model.db.ResultSetMapper; +import it.integry.ems_model.entity.*; +import it.integry.ems_model.exception.DataConverterNotFoundException; +import it.integry.ems_model.rules.util.DroolsUtil; +import it.integry.ems_model.service.SetupGest; +import it.integry.ems_model.types.OperationType; +import it.integry.ems_model.utility.Query; +import it.integry.ems_model.utility.UtilityDB; +import it.integry.ems_model.utility.UtilityHashMap; +import it.integry.ems_model.utility.UtilityString; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.sql.*; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.*; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +public class GeneraOrdLav { + public static void getNextCodJcom(Connection conn, CommessaDTO datiComm, OrdProdSetupDTO ordProdSetupDTO) throws Exception { + // Acquisizione configurazioni commessa + boolean generazioneAutomatica = false; + boolean aggiungiGestione = false; + if ("V".equals(datiComm.getGestione())) { + generazioneAutomatica = ordProdSetupDTO.isGenerazioneAutomaticaVend(); + aggiungiGestione = ordProdSetupDTO.isAggiungiGestione(); + } else if ("L".equals(datiComm.getGestione()) || "A".equals(datiComm.getGestione())) { + generazioneAutomatica = ordProdSetupDTO.isGenerazioneAutomaticaLav(); + } + + // Definizione nuovo codice commessa + if (generazioneAutomatica) { + datiComm.setNumComm(""); + if (datiComm.getDataOrd() != null && datiComm.getNumOrd() != null) { + SimpleDateFormat dateFormat = new SimpleDateFormat("yy"); + datiComm.setNumComm(dateFormat.format(datiComm.getDataOrd()).toString() + UtilityString.leftPad(datiComm.getNumOrd().toString(), 5, '0')); + } + if (aggiungiGestione) { + String numComm = ""; + numComm = datiComm.getGestione() + numComm; + datiComm.setNumComm(numComm); + } + + String parameter = datiComm.getNumComm(); + String sql = " select dbo.f_suggestCodeCodJcom(" + UtilityDB.valueToString(parameter) + ", 0) "; + String codJcom = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + datiComm.setCodjcom(codJcom); + } + } + + private static void assegnaCodJcom(CommessaDTO datiComm, DtbOrdr dtbOrdr) { + JtbComt jtbComt = new JtbComt() + .setCodJcom(datiComm.getCodjcom()) + .setTipoAnag(datiComm.getTipoAnag()) + .setCodAnag(datiComm.getCodAnag()) + .setDescrizione(datiComm.getDescrComm()) + .setDataOrd(datiComm.getDataOrd()) + .setNumOrd(datiComm.getNumOrd()); + if (datiComm.getDataInizLav() != null) { + jtbComt.setDataIniziLav(datiComm.getDataInizLav()); + } + if (datiComm.getDataCons() != null) { + jtbComt.setDataCons(datiComm.getDataCons()); + } + if (datiComm.getNumComm().length() != 0 && "V".equals(datiComm.getGestione())) { + jtbComt.setDataOrd(datiComm.getDataOrd()); + + } + jtbComt.setOperation(OperationType.INSERT); + dtbOrdr.setCodJcom(datiComm.getCodjcom()) + .setJtbComt(jtbComt); + + + } + + private static String getNextActivityId(Connection connect) throws Exception { + return ConfigActivityRules.completeActivityId(connect); + } + + private static String getCodJflav(Connection conn, String userName, String codJflavDef) throws Exception { + String sql = + Query.format( + " SELECT cod_jflav " + + " FROM jrl_flav_users " + + "WHERE user_name = %s AND " + + " flag_jflav_default = 'S'", userName); + + String codJflav = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + + if (UtilityString.isNullOrEmpty(codJflav)) { + if (UtilityString.isNullOrEmpty(codJflavDef)) + throw new Exception("CODICE LAVORATO DI DEFAULT NON CONFIGURATO"); + + codJflav = codJflavDef; + } + return codJflav; + } + + private static String generateActivity(Connection connect, DtbOrdr dtbOrdr, String codProd, String codJcom, String gestione, Date dataOrd, Integer numOrd, String userName, String activityID, Enum operationType, List activityCicloProd) throws Exception { + Integer durataFasiPrec = 0; + Date dataIniz = null, dataFine = null, oraDataMod = new Date(); + String classNameOrdProd = "W_PORDI_RC", activityIDRoot = null, activityTypeID = null, flagTipologia = null, sql; + StbActivity activity = new StbActivity(); + List activityList = new ArrayList(); + SetupGest setup = new SetupGest(); + PreparedStatement ps = null; + ResultSet rs = null; + + String assegnaAttività = setup.getSetup(connect, classNameOrdProd, "ACTIVITY", "GENERA_ATTIVITA"); + if (UtilityString.isNullOrEmpty(assegnaAttività)) { + assegnaAttività = "N"; + } + String tipoGenerazione = setup.getSetup(connect, classNameOrdProd, "ACTIVITY", "TIPO_GENERAZIONE"); + if (UtilityString.isNullOrEmpty(tipoGenerazione)) { + tipoGenerazione = ""; + } + + if (tipoGenerazione.length() == 0 && "S".equals(assegnaAttività)) { + throw new Exception("E' necessario specificare la tipologia di generazione attività per poter procedere"); + } + + if (operationType == OperationType.UPDATE) { + // Aggiornamento attività + activityIDRoot = activityID; + sql = " select stb_activity.activity_id, " + + " jtb_dist_clav_dir.num_fase " + + " from (select activity_id, cod_prod from dtb_ordt " + + " where dtb_ordt.gestione = " + UtilityDB.valueToString(gestione) + " and " + + " dtb_ordt.num_ord = " + UtilityDB.valueToString(numOrd) + " and " + + " dtb_ordt.data_ord = " + UtilityDB.valueDateToString(dataOrd, CommonConstants.DATE_FORMAT_YMD) + " )actOrd, " + + " stb_activity, " + + " jtb_dist_clav_dir " + + " where (actOrd.activity_id = stb_activity.activity_id or " + + " actOrd.activity_id = stb_activity.parent_activity_id) and " + + " actOrd.cod_prod = jtb_dist_clav_dir.cod_prod and " + + " stb_activity.activity_type_id = jtb_dist_clav_dir.activity_type_id and " + + " stb_activity.flag_tipologia = jtb_dist_clav_dir.flag_tipologia AND " + + " jtb_dist_clav_dir.flag_fase_pref = 'S' " + + " union all " + + " select activity_id, 0 from dtb_ordt " + + " where dtb_ordt.gestione = " + UtilityDB.valueToString(gestione) + " and " + + " dtb_ordt.num_ord = " + UtilityDB.valueToString(numOrd) + " and " + + " dtb_ordt.data_ord = " + UtilityDB.valueDateToString(dataOrd, CommonConstants.DATE_FORMAT_YMD); + + ps = connect.prepareStatement(sql); + rs = ps.executeQuery(); + while (rs.next()) { + String activityIDLav = rs.getString(1); + Integer numFase = rs.getInt(2); + ActivityCicloProdDTO activityCicloProdDTO = new ActivityCicloProdDTO(); + activityCicloProdDTO.setActivityID(activityIDLav); + activityCicloProdDTO.setNumFase(numFase); + activityCicloProd.add(activityCicloProdDTO); + + activity = new StbActivity(); + activity.setOperation(OperationType.UPDATE); + activity.setActivityId(activityIDLav); + activity.setCodJcom(codJcom); + activity.setUserName(userName); + activity.setOraModAct(oraDataMod); + activityList.add(activity); + } + rs.close(); + ps.close(); + } else { + if (tipoGenerazione.equals("PROCESSO PRODUTTIVO")) { + // Creazione attività processo padre + sql = + "select jtb_cicl.activity_type_id , " + + " jtb_cicl.flag_tipologia, " + + " sum(dbo.f_distGetValueType('DD', jtb_dist_clav_dir.duration)) as durata " + + " from jtb_cicl, " + + " jtb_dist_clav_dir " + + " where jtb_cicl.cod_prod = " + UtilityDB.valueToString(codProd) + " AND " + + " jtb_dist_clav_dir.flag_fase_pref = 'S' " + + " group by jtb_cicl.activity_type_id , jtb_cicl.flag_tipologia"; + + ps = connect.prepareStatement(sql); + rs = ps.executeQuery(); + while (rs.next()) { + activityTypeID = rs.getString(1); + flagTipologia = rs.getString(2); + Integer durataFase = rs.getInt(3); + activityIDRoot = getNextActivityId(connect); + + // Calcolo data inizio e fine prevista attività + Calendar cal = Calendar.getInstance(); + cal.setTime(dtbOrdr.getDataCons()); + cal.add(Calendar.DATE, durataFasiPrec); + dataIniz = cal.getTime(); + cal.setTime(dataIniz); + cal.add(Calendar.DATE, durataFase); + dataFine = cal.getTime(); + + // Inserimento attività + activity = new StbActivity(); + activity.setOperation(OperationType.INSERT_OR_UPDATE); + activity.setActivityId(activityIDRoot); + activity.setCodJcom(codJcom); + activity.setActivityTypeId(activityTypeID); + activity.setFlagTipologia(flagTipologia); + activity.setUserName(userName); + activity.setActivityDescription(activityTypeID + " N° " + numOrd.toString() + " DEL + " + new SimpleDateFormat("yyyy/MM/dd").format(dataOrd)); + activity.setEstimatedDate(dataIniz); + activity.setEstimatedEnddate(dataFine); + activity.setEstimatedTime(dataIniz); + activity.setEstimatedEndtime(dataFine); + activity.setOraModAct(oraDataMod); + activity.setGestione("L"); + activity.setDataOrd(dataOrd); + activity.setNumOrd(numOrd); + activityList.add(activity); + } + rs.close(); + ps.close(); + + // Creazione attività sottoprocessi ciclo produttivo + sql = + "select activity_type_id, " + + " flag_tipologia, " + + " dbo.f_distGetValueType('DD', jtb_dist_clav_dir.duration) as durata, " + + " jtb_dist_clav_dir.num_fase " + + " from jtb_dist_clav_dir " + + " where jtb_dist_clav_dir.cod_prod = " + UtilityDB.valueToString(codProd) + " AND " + + " jtb_dist_clav_dir.flag_fase_pref = 'S' " + + "order by num_Fase "; + + ps = connect.prepareStatement(sql); + rs = ps.executeQuery(); + while (rs.next()) { + activityTypeID = rs.getString(1); + flagTipologia = rs.getString(2); + Integer durataFase = rs.getInt(3); + Integer numFase = rs.getInt(4); + activityID = getNextActivityId(connect); + ActivityCicloProdDTO activityCicloProdDTO = new ActivityCicloProdDTO(); + activityCicloProdDTO.setActivityID(activityID); + activityCicloProdDTO.setNumFase(numFase); + activityCicloProd.add(activityCicloProdDTO); + + // Calcolo data iniizo e fine prevista attività + Calendar cal = Calendar.getInstance(); + cal.setTime(dtbOrdr.getDataCons()); + cal.add(Calendar.DATE, durataFasiPrec); + dataIniz = cal.getTime(); + cal.setTime(dataIniz); + cal.add(Calendar.DATE, durataFase); + dataFine = cal.getTime(); + durataFasiPrec += durataFase; + + // Inserimento attività + activity = new StbActivity(); + activity.setOperation(OperationType.INSERT_OR_UPDATE); + activity.setActivityId(activityID); + activity.setParentActivityId(activityIDRoot); + activity.setCodJcom(codJcom); + activity.setActivityTypeId(activityTypeID); + activity.setFlagTipologia(flagTipologia); + activity.setUserName(userName); + activity.setActivityDescription(activityTypeID); + activity.setEstimatedDate(dataIniz); + activity.setEstimatedEnddate(dataFine); + activity.setEstimatedTime(dataIniz); + activity.setEstimatedEndtime(dataFine); + activity.setOraModAct(oraDataMod); + activity.setGestione("L"); + activity.setDataOrd(dataOrd); + activity.setNumOrd(numOrd); + activityList.add(activity); + } + rs.close(); + ps.close(); + } else if (tipoGenerazione.equals("ORDINE PRODUZIONE")) { + // Acquisizione dati distinta base + sql = + "select jtb_cicl.activity_type_id , " + + " jtb_cicl.flag_tipologia, " + + " sum(dbo.f_distGetValueType('DD', jtb_dist_clav_dir.duration)) as durata " + + " from jtb_cicl, " + + " jtb_dist_clav_dir " + + " where jtb_cicl.cod_prod = " + UtilityDB.valueToString(codProd) + " AND " + + " jtb_dist_clav_dir.flag_fase_pref = 'S' " + + " group by jtb_cicl.activity_type_id , jtb_cicl.flag_tipologia"; + + ps = connect.prepareStatement(sql); + rs = ps.executeQuery(); + while (rs.next()) { + activityTypeID = rs.getString(1); + flagTipologia = rs.getString(2); + Integer durataFase = rs.getInt(3); + activityIDRoot = getNextActivityId(connect); + + // Calcolo data iniizo e fine prevista attività + Calendar cal = Calendar.getInstance(); + cal.setTime(dtbOrdr.getDataCons()); + cal.add(Calendar.DATE, durataFasiPrec); + dataIniz = cal.getTime(); + cal.setTime(dataIniz); + cal.add(Calendar.DATE, durataFase); + dataFine = cal.getTime(); + durataFasiPrec += durataFase; + } + + activity = new StbActivity(); + activity.setOperation(OperationType.INSERT_OR_UPDATE); + activity.setActivityId(activityIDRoot); + activity.setCodJcom(codJcom); + activity.setActivityTypeId(activityTypeID); + activity.setFlagTipologia(flagTipologia); + activity.setEstimatedDate(dataIniz); + activity.setEstimatedEnddate(dataFine); + activity.setEstimatedTime(dataIniz); + activity.setEstimatedEndtime(dataFine); + activity.setOraModAct(oraDataMod); + activity.setUserName(userName); + activity.setGestione("L"); + activity.setDataOrd(dataOrd); + activity.setNumOrd(numOrd); + activity.setActivityDescription("PRODUZIONE N° " + numOrd.toString() + " DEL + " + new SimpleDateFormat("yyyy/MM/dd").format(dataOrd)); + activityList.add(activity); + } + } + + if (activityList.size() != 0) { + dtbOrdr.setStbActivityList(activityList); + } + return activityIDRoot; + } + + private static void assegnaPartitaMag(Connection conn, DtbOrdr dtbOrdr, OrdProdSetupDTO ordProdSetupDTO) throws Exception { + String gestione = "L", parameter, sql = ""; + Date dataScad = null; + DateFormat formato = new SimpleDateFormat("yyyy/MM/dd"); + + String codJfas = dtbOrdr.getCodJfas(); + String codMdep = dtbOrdr.getCodMdep(); + String codMart = dtbOrdr.getCodMart(); + String partitaMag = dtbOrdr.getPartitaMag(); + String codAnag = dtbOrdr.getCodAnag(); + Date dataOrd = dtbOrdr.getDataOrd(); + Integer numOrd = dtbOrdr.getNumOrd(); + Date dataCons = dtbOrdr.getDataCons(); + + boolean generaLottoProdAutomatico = ordProdSetupDTO.isGeneraLottoAut(codMdep); + boolean partitaMagRequired = ordProdSetupDTO.isPartitaMagRequired(); + + // Se il prodotto è presente tra quelli da escludere dall'assegnazione automatica allora non viene generato il lotto + String whereCondEscludiProd = ordProdSetupDTO.getWhereCondEscludiProd(codMdep); + if (!UtilityString.isNullOrEmpty(whereCondEscludiProd)) { + sql = " select CAST(count(*) as BIT ) " + + " from mtb_aart INNER JOIN jtb_cicl ON mtb_aart.cod_mart = jtb_cicl.cod_prod " + + " where mtb_aart.cod_mart = " + UtilityDB.valueToString(codMart); + sql = UtilityDB.addwhereCond(sql, whereCondEscludiProd, true); + boolean escludiArt = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + + if (escludiArt) { + generaLottoProdAutomatico = false; + partitaMagRequired = false; + } + } + + if (generaLottoProdAutomatico) { + DatiPartitaMagDTO datiPartita = + new DatiPartitaMagDTO() + .setCodMart(codMart) + .setPartitaMag(partitaMag) + .setCodAnag(codAnag) + .setGestione(gestione) + .setDataOrd(dataOrd) + .setNumOrd(numOrd) + .setCodJfas(codJfas); + parameter = datiPartita.getParmSuggestCode(); + + sql = " select dbo.f_suggestCodePartitaMag(" + UtilityDB.valueToString(parameter) + ", 0) "; + partitaMag = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + + if (partitaMag != null && partitaMag.length() != 0) { + // Definizione data scadenza partita di magazzino + parameter = codMart + ';' + + formato.format(dataCons) + ';' + + codJfas + ";" + + formato.format(dataOrd) + ";" + /*data ordine produzione*/ + numOrd + ";" /*numero ordine di produzione*/ + /*Data ordine e numero ordine di lavorazione non vengono passati perchè in questa fase non esistono*/; + + sql = " select convert(datetime, dbo.f_suggestCodeDataScadPartitaMag(" + UtilityDB.valueToString(parameter) + ", 0)) "; + dataScad = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + + if (dataScad != null) { + dtbOrdr.setMtbPartitaMag(new MtbPartitaMag()); + dtbOrdr.getMtbPartitaMag().setOperation(OperationType.INSERT); + dtbOrdr.getMtbPartitaMag().setCodMart(codMart); + dtbOrdr.getMtbPartitaMag().setPartitaMag(partitaMag); + dtbOrdr.getMtbPartitaMag().setDataScad(dataScad); + dtbOrdr.setPartitaMag(partitaMag); + } + } else { + if (partitaMagRequired && partitaMag == null) { + throw new Exception("Partita di magazzino obbligatoria, impossibile procedere alla generazione"); + } + } + } else { + if (partitaMagRequired && partitaMag == null) { + throw new Exception("Partita di magazzino obbligatoria, impossibile procedere alla generazione"); + } + } + } + + private static void explodeDist(DtbOrdt ordT, Connection conn, + EntityBase dtbOrdr, + List activityCicloProd, + boolean existOrd, + OrdProdSetupDTO ordProdSetupDTO, + HashMap datiProd, + List mtbUntMis) throws Exception { + String codJfasRow = null; + Integer durataFasiPrec = 0, numFaseOld = 0; + String untMisPRI = null, sql = null, fasiCicloProdOrdine = null, columnFaseCicloProdOrd = "", tableCicloProdOrd = "", columnFaseParentCicloProdOrd = ""; + Date dataConsRow = null, dataIniz = null, dataFine = null; + PreparedStatement ps = null; + ResultSet rs = null; + BigDecimal rapConvPRI = BigDecimal.ZERO; + + boolean assPeriodoFase = ordProdSetupDTO.isAssPeriodoFase(); + boolean visCodJfas = ordProdSetupDTO.isVisCodJfas(); + boolean visNoteRigaDist = ordProdSetupDTO.isVisNoteRigaDist(); + boolean pesoInQtaLav = ordProdSetupDTO.isPesoInQtaLav(); + boolean isSameLav = true; + + String fasiSel = UtilityHashMap.getValueIfExists(datiProd, "elenco_fasi"); + String[] elencoFasi; + if (fasiSel != null) { + elencoFasi = fasiSel.split("\\|"); + } else { + elencoFasi = new String[]{}; + } + if (elencoFasi.length != 0) { + codJfasRow = elencoFasi[0]; + } + + String codProd = UtilityHashMap.getValueIfExists(datiProd, "cod_prod"); + String untMisProd = UtilityHashMap.getValueIfExists(datiProd, "unt_mis_prod"); + BigDecimal qtaProd = UtilityHashMap.getValueIfExists(datiProd, "qta_prod"); + BigDecimal rapConv = UtilityHashMap.getValueIfExists(datiProd, "rap_conv"); + Date dataConsDist = UtilityHashMap.getValueIfExists(datiProd, "data_cons"); + + // ----------------------------------------------------------- + // GENERAZIONE TESTATE E RIGHE ORDINE DI LAVORAZIONE + // ----------------------------------------------------------- + BigDecimal qtaProdDist = UtilityHashMap.getValueIfExists(datiProd, "qta_prod"); + BigDecimal rapConvDist = UtilityHashMap.getValueIfExists(datiProd, "rap_conv_prod"); + qtaProdDist = qtaProdDist.multiply(rapConvDist).setScale(EmsRestConstants.cifreDecMax, BigDecimal.ROUND_HALF_UP); + String codJfasDist = UtilityHashMap.getValueIfExists(datiProd, "cod_jfas"); + untMisPRI = UtilityHashMap.getValueIfExists(datiProd, "unt_mis_prod"); + rapConvPRI = rapConvDist; + + +// //lista degli articoli che hanno distinta +// sql = "SELECT DISTINCT cod_mart FROM dbo.getmaterialidistinta(%s) WHERE is_foglia = 0"; +// List articoli = UtilityDB.executeSimpleQueryOnlyFirstColumn(conn, sql); +// +// /* +// Riempiamo una lista con i dati della distinta e impostiamo come default sameLav = true solo se trova nella +// distinta un cambio di fase lo segnamo nella lista +// */ +// List artDist = articoli +// .stream() +// .map( +// x -> { +// ExplodeDistDTO explodeDistDTO = new ExplodeDistDTO() +// .setCodProd(codProd) +// .setRoot(codProd.equalsIgnoreCase(x)) +// .setSameLav(true); +// return explodeDistDTO; +// } +// ).collect(Collectors.toList()); + + List artDist = new ArrayList<>(); + artDist.add(new ExplodeDistDTO().setCodProd(codProd).setRoot(true).setNumFase(0)); + + List jtbDistMates; + if (((DtbOrdr) dtbOrdr).getDistinta() == null ) { + sql = + Query.format( + "SELECT jtb_dist_mate.cod_mart,\n" + + " jtb_dist_mate.descrizione,\n" + + " jtb_dist_mate.descrizione_estesa,\n" + + " jtb_dist_mate.unt_mis_prod as unt_mis_dist,\n" + + " jtb_dist_mate.rap_conv_prod as rap_conv_dist,\n" + + " jtb_dist_mate.qta_prod AS qta_std,\n" + + " jtb_dist_mate.num_fase,\n" + + " jtb_dist_mate.flag_pri,\n" + + " jtb_dist_mate.perc_sfrido,\n" + + " jtb_dist_mate.note\n" + + "FROM dbo.getmaterialidistinta(%s) jtb_dist_mate\n" + + "WHERE is_foglia = 1\n" + + "ORDER BY item_id", codProd); + + jtbDistMates = UtilityDB.executeSimpleQueryDTO(conn, sql, JtbDistMate.class); + } else { + jtbDistMates = ((DtbOrdr) dtbOrdr).getDistinta(); + } + + for (JtbDistMate mp: jtbDistMates) { + String descrMate= mp.getDescrizione(); + String descrEstesaMate = mp.getDescrizioneEstesa(); + BigDecimal qtaMate = mp.getQtaStd(); + BigDecimal percSfrido = mp.getPercSfrido(); + qtaMate = qtaMate.multiply(BigDecimal.ONE.add(percSfrido.divide(new BigDecimal(100)))).setScale(EmsRestConstants.cifreDecMax, BigDecimal.ROUND_HALF_UP); + BigDecimal rapporto = qtaProd.divide(qtaProdDist, EmsRestConstants.cifreDecMax, RoundingMode.HALF_UP); + BigDecimal qta = qtaMate.multiply(rapporto); + + String untMisDist = mp.getUntMisDist(); + String flagUMDig = + String.valueOf(mtbUntMis.stream().filter(x->x.getUntMis().equalsIgnoreCase(untMisDist)) + .findFirst() + .map(x->x.getFlagDig())); + + // Verifica se la materia prima ha unità di misura digitale in tal caso verrà arrotondata all'intero + if ("S".equals(flagUMDig)) { + qta = qta.setScale(0, RoundingMode.CEILING); + } + + if (mp.getCodMart() != null) { + sql = "SELECT Cast(count(*) as bit) FROM mtb_aart WHERE cod_mart = " + UtilityDB.valueToString(mp.getCodMart()); + boolean existArt = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + if (!existArt) { + throw new Exception("PRODOTTO " + mp.getCodMart() + " NON PRESENTE IN ANAGRAFICA ARTICOLI"); + } + } else { + if (descrMate == null) { + descrMate = UtilityString.left(descrEstesaMate, 40); + } + } + + Integer numFase = mp.getNumFase(); + // Calcolo data consegna materiali per fase di lavoro + if (assPeriodoFase) { + if (numFase != numFaseOld) { + Integer durataFase = getDurataFase(conn, codProd); + Calendar cal = Calendar.getInstance(); + cal.setTime(dataConsDist); + cal.add(Calendar.DATE, durataFase); + dataConsRow = cal.getTime(); + durataFasiPrec += durataFase; + } + } + + // Inserimento riga materiale nell'ordine di lavorazione + DtbOrdr ordR = + new DtbOrdr() + .setCodMart(mp.getCodMart()) + .setCodJcom(ordT.getCodJcom()) + .setDescrizione(descrMate) + .setDescrizioneEstesa(descrEstesaMate) + .setQtaOrd(qta) + .setUntOrd(untMisDist) + .setRapConv(mp.getRapConvDist()); + + if (visNoteRigaDist) ordR.setNote(mp.getNote()); + + ordR.setOperation(OperationType.INSERT); + if (assPeriodoFase) { + ordR.setDataCons(dataConsRow); + } else { + ordR.setDataCons(dataConsDist); + } + + if (UtilityString.equalsIgnoreCase(mp.getFlagPri(),"S")) { + sql = + Query.format( + "SELECT CAST(count(*) as BIT) FROM jtb_cicl WHERE cod_prod = " + UtilityDB.valueToString(mp.getCodMart()) + " AND IsNull(cod_jfas, '') <> %s", + codJfasDist); + isSameLav = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + } + + if (isSameLav) + ordR.setNumFase(numFase + mp.getNumFase()); + else { + ordR.setNumFase(numFase); + artDist.add(new ExplodeDistDTO().setCodProd(mp.getCodProd()).setRoot(false)); + } + + numFaseOld = numFase; + ordT.addDtbOrdr(ordR); + } + + + // ------------------------------------------------------------------------------------- + // SE L'ORDINE E' GIà ESISTENTE E CI SONO DEI FILES ALLEGATI ALLORA VENGONO AGGANCIATI + // ------------------------------------------------------------------------------------- +// if (existOrd) { +// sql = "select id_attach " + +// "from drl_ord_attached " + +// " where gestione = " + UtilityDB.valueToString(ordT.getGestione()) + " AND " + +// " data_ord = " + UtilityDB.valueDateToString(ordT.getDataOrd(), CommonConstants.DATE_FORMAT_YMD) + " and " + +// " num_ord = " + UtilityDB.valueToString(ordT.getNumOrd()); +// ps = conn.prepareStatement(sql); +// rs = ps.executeQuery(); +// while (rs.next()) { +// String idAttach = rs.getString(1); +// DrlOrdAttached ordAttacched = new DrlOrdAttached(); +// ordAttacched.setOperation(OperationType.INSERT); +// ordAttacched.setIdAttach(idAttach); +// ordT.getDrlOrdAttached().add(ordAttacched); +// } +// rs.close(); +// ps.close(); +// } + + + List articoli = + artDist.stream().map(x->x.getCodProd()).collect(Collectors.toList()); + // ------------------------------------------------------------------ + // ATTIVITA' ASSOCIATE ALLA DISTINTA (RISORSE o STEPS) + // ------------------------------------------------------------------ +// addSteps(ordT, conn, activityCicloProd, ordProdSetupDTO, multiLavorazione, fasiSel, cicloProdJson, fasiCicloProdOrdine, codProd, codJfasRow, visCodJfas, untMisProd, qtaProd, rapConv, untMisPRI, rapConvPRI, assPeriodoFase, dataConsDist, dataIniz, dataFine, elencoFasi, pesoInQtaLav); + + // --------------------------------------------------------------------------- + // CONTROLLI DI QUALITA' ASSOCIATI ALLA DISTINTA + // --------------------------------------------------------------------------- +// addControlliQualità(ordT, conn, codProd); + + // ------------------------------------------------- + // DISEGNI ORDINE DI LAVORAZIONE + // ------------------------------------------------- + addDisegni(ordT, conn, articoli); + } + + private static void addSteps(DtbOrdt ordT, Connection conn, List activityCicloProd, OrdProdSetupDTO ordProdSetupDTO, boolean multiLavorazione, String fasiSel, String cicloProdJson, String fasiCicloProdOrdine, String codProd, String codJfasRow, boolean visCodJfas, String untMisProd, BigDecimal qtaProd, BigDecimal rapConv, String untMisPRI, BigDecimal rapConvPRI, boolean assPeriodoFase, Date dataConsDist, Date dataIniz, Date dataFine, String[] elencoFasi, boolean pesoInQtaLav) throws Exception { + /*Se cicloProd != null allora vuol dire che il ciclo produttivo è stato passato dall'esterno e quindi dovrà essere sviluppato + questo ciclo produttivo e non quello presente nella distinta base (Al momento solo per le distinte multifase funziona, + per quelle monofase non è ancora attivo, ma verrà sostituito in seguito*/ +// String cicloProdJson = ((DtbOrdr) dtbOrdr).getSystemNote(); +// if (cicloProdJson != null) { +// JSONArray jsonArray = new JSONArray(cicloProdJson); +// fasiCicloProdOrdine = ""; +// for (int i = 0; i < jsonArray.length(); i++) { +// fasiCicloProdOrdine += "(" + UtilityDB.valueToString(jsonArray.getJSONObject(i).getInt("numFase")) + ","; +// fasiCicloProdOrdine += UtilityDB.valueToString(jsonArray.getJSONObject(i).getString("codJfas")) + ","; +// fasiCicloProdOrdine += UtilityDB.valueToString(jsonArray.getJSONObject(i).getString("codJfasChild")) + "),"; +// } +// fasiCicloProdOrdine = UtilityString.left(fasiCicloProdOrdine, fasiCicloProdOrdine.length() - 1); +// } +// +// // ------------------------------------------------------ +// // Se la distinta prevede più fasi di lavorazione associate con flag_fase_pref = 'S' e la tipologia attivittà è la stessa per tutte le fasi (si potrebbe anche lavorare sulla fase), +// // allora vuol dire che si tratta di una distinta con un unica fase di lavorazione , ma formata da più cicli di lavorazione ed in tal caso la fase passata da fuori deve avere la precedenza su quella della distinta base +// // (E' il caso di SUIT per quanto riguarda le soccide, dove la fase corrisponde sempre alla soccida cioè al deposito) ma la tipologia attività è la stessa per ogni fase allora vuol dire che e ci sono più tipologie attività associate la generazione dell'ordine deve essere fatta vecchia maniera riportando negli step +// // Se invece la distinta prevede più fasi di lavorazione ma con tipologia attività diversa sulle singole fasi allora la fase della distinta deve avere precedenza +// // (E' il caso di SUIT Scrofaie e di VIENELLA) +// // ------------------------------------------------------ +// boolean multiLavorazione = false; +// if (fasiSel == null) { +// /*Se dall'esterno non è stato passato alcuna fase allora vuol dire che le fasi devono essere quelle specificate nella distinta base*/ +// multiLavorazione = true; +// } else { +// sql = "select CAST(CASE WHEN count(*) > 1 THEN 1 ELSE 0 END as bit) " + +// " from (select DISTINCT activity_type_id, flag_tipologia, flag_fase_pref " + +// " from jtb_dist_clav_dir " + +// "where cod_prod = " + UtilityDB.valueToString(codProd) + " and " + +// " cod_jfas IS NOT NULL and " + +// " flag_fase_pref = 'S')pref"; +// +// multiLavorazione = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); +// } + + +// String columnFaseCicloProdOrd; +// String columnFaseParentCicloProdOrd; +// ResultSet rs; +// PreparedStatement ps; +// String sql; +// String codJfasDist; +// String tableCicloProdOrd; +// Integer durataFasiPrec; +// String qtaProdPRI = "", condFasi = ""; +// durataFasiPrec = 0; +// +// if (!multiLavorazione) { +// condFasi = "(fasParent.cod_jfas_parent IS NOT NULL OR jtb_dist_clav_dir.cod_jfas in ('" + UtilityString.replaceSubString(fasiSel, "|", "','") + "'))"; +// } +// +// +// sql = ""; +// columnFaseCicloProdOrd = "jtb_dist_clav_dir.cod_jfas"; +// columnFaseParentCicloProdOrd = "cod_jfas_parent "; +// tableCicloProdOrd = ""; +// if (cicloProdJson != null) { +// columnFaseCicloProdOrd = "ISNULL(cicloProdOrd.cod_jfas_child, jtb_dist_clav_dir.cod_jfas)"; +// columnFaseParentCicloProdOrd = "case when cicloProdOrd.cod_jfas IS NULL then cod_jfas_parent else null end "; +// tableCicloProdOrd = "left outer join cicloProdOrd on jtb_dist_clav_dir.cod_jfas = cicloProdOrd.cod_jfas and " + +// " jtb_dist_clav_dir.num_fase = cicloProdOrd.num_fase "; +// sql = " with cicloProdOrd AS (SELECT * FROM (VALUES " + fasiCicloProdOrdine + " ) fasi([num_fase],[cod_jfas],[cod_jfas_child] ))"; +// } +// +// sql += " SELECT " + columnFaseCicloProdOrd + " as 'cod_jfas', " +// + " jtb_dist_clav_dir.activity_description, " +// + " jtb_dist_clav_dir.num_fase, " +// + " convert(varchar(8000), jtb_cicl.descrizione) as dati_tecnici, " +// + " dbo.f_distGetValueType('DD', jtb_dist_clav_dir.duration) as durata, " +// + " " + columnFaseParentCicloProdOrd + " as 'cod_jfas_parent' " +// + " FROM jtb_dist_clav_dir left outer join (select distinct cod_jfas_parent from jtb_fasi where cod_jfas_parent is not null)fasparent ON jtb_dist_clav_dir.cod_jfas = fasParent.cod_jfas_parent " + +// tableCicloProdOrd + ", " +// + " jtb_cicl, " +// + " gtb_spes, " +// + " gtb_divi " +// + " WHERE jtb_dist_clav_dir.cod_jcos_dir = gtb_spes.cod_spes AND " +// + " jtb_cicl.cod_prod = jtb_dist_clav_dir.cod_prod AND " +// + " jtb_cicl.cod_divi_cont = gtb_divi.cod_divi AND " +// + " jtb_dist_clav_dir.cod_prod = " + UtilityDB.valueToString(codProd) + " AND " +// + " jtb_dist_clav_dir.cod_jfas IS NOT NULL " +// + "ORDER BY jtb_dist_clav_dir.num_fase "; +// +// sql = UtilityDB.addwhereCond(sql, condFasi, true); +// ps = conn.prepareStatement(sql); +// rs = ps.executeQuery(); +// BigDecimal rapConvRow = BigDecimal.ONE; +// String untMisRow = null; +// while (rs.next()) { +// String codJfas = rs.getString("cod_jfas"); +// codJfasDist = codJfas; +// String activityDescription = rs.getString("activity_description"); +// Integer numFaseDist = rs.getInt("num_fase"); +// String datiTecnici = rs.getString("dati_tecnici"); +// Integer durataFase = rs.getInt("durata"); +// String codJfasParent = rs.getString("cod_jfas_parent"); +// +// BigDecimal qtaProdRow; +// if (isRoot) { +// // Se il codice della fase della distinta è diverso dal codice fase del ciclo produttivo allora è necessario verificare +// // il codice fase del ciclo produttivo ha un codice di equivalenza/relazione associato alla fase specificata dall'utente +// // ed in tal caso sostituirlo +// // La struttura delle fasi dovrebbe essere uguale per i primi 4 caratteri e l'ultimo cambiare (Es.: LAV1 --> IMPA1, COTT1 e l'altra linea LAV2 --> IMPA2, COTT2) +// String existCodJfasEqui = ordProdSetupDTO.getExistCodJfasEqui(); +// if (UtilityString.isNullOrEmpty(existCodJfasEqui)) { +// existCodJfasEqui = "N"; +// } +// if (existCodJfasEqui.compareTo("S") == 0) { +// sql = "select cod_jfas from jtb_fasi where cod_jfas like left(" + UtilityDB.valueToString(codJfas) + ", 4) + '%' and cod_jfas_parent = " + UtilityDB.valueToString(codJfasRow); +// codJfas = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); +// } +// if (visCodJfas) { +// activityDescription = UtilityString.left("(" + codJfas + ") " + activityDescription, 1024); +// } else { +// activityDescription = UtilityString.left(activityDescription, 1024); +// } +// untMisRow = untMisProd; +// qtaProdRow = qtaProd; +// rapConvRow = rapConv; +// qtaProdPRI = ""; +// } else { +// untMisRow = untMisPRI; +// qtaProdRow = qtaProd; +// rapConvRow = rapConvPRI; +// qtaProdPRI = " " + untMisPRI + " " + qtaProd.setScale(2, RoundingMode.HALF_UP).toString(); +// } +// // Calcolo periodo produzione per fase +// if (assPeriodoFase) { +// Calendar cal = Calendar.getInstance(); +// cal.setTime(dataConsDist); +// cal.add(Calendar.DATE, durataFasiPrec); +// dataIniz = cal.getTime(); +// cal.setTime(dataIniz); +// cal.add(Calendar.DATE, durataFase); +// dataFine = cal.getTime(); +// durataFasiPrec += durataFase; +// } +// +// String[] elencoFasiAss = null; +// if (multiLavorazione) { +// elencoFasiAss = new String[1]; +// elencoFasiAss[0] = codJfas; +// } else { +// // Verifica linee passate dall'utente rispetto a quelle di default presenti sulla distinta +// sql = +// "select count(*) " + +// " from jtb_fasi " + +// " where cod_jfas_parent = " + UtilityDB.valueToString(codJfas); +// Integer isFaseParent = (Integer) QueryRules.getSingleValue(conn, sql); +// +// if (isRoot) { +// if (codJfasParent != null || isFaseParent > 0) { +// elencoFasiAss = elencoFasi; +// } else { +// boolean existFase = false; +// for (int a = 0; a < elencoFasi.length; a++) { +// if (codJfas.compareTo(elencoFasi[a]) == 0) { +// existFase = true; +// break; +// } +// } +// if (!existFase) { +// elencoFasiAss = elencoFasi; +// continue; +// } else { +// elencoFasiAss = new String[1]; +// elencoFasiAss[0] = codJfas; +// } +// } +// } else { +// elencoFasiAss = elencoFasi; +// } +// } +// +// BigDecimal qtaLav = BigDecimal.ZERO; +// for (int a = 0; a < elencoFasiAss.length; a++) { +// datiDist.setIdRigaStep(datiDist.getIdRigaStep() + 1); +// +// if (pesoInQtaLav) { +// qtaLav = qtaProd.divide(rapConv, EmsRestConstants.cifreDecMax, RoundingMode.HALF_UP); +// } +// +// // Inserimento riga step nell'ordine di lavorazione +// DtbOrdSteps ordStep = +// new DtbOrdSteps() +// .setCodProdPri(codProd) +// .setIdRiga(datiDist.getIdRigaStep()) +// .setCodJfas(elencoFasiAss[a]) +// .setDescrizioneAttivita(activityDescription + qtaProdPRI) +// .setQtaProd(qtaProdRow.divide(rapConv, EmsRestConstants.cifreDecMax, RoundingMode.HALF_UP)) +// .setQtaLav(qtaLav) +// .setUntMisLav(untMisRow) +// .setRapConvLav(rapConvRow); +// +// ordStep.setOperation(OperationType.INSERT); +// if (isRoot) { +// ordStep.setNumFase(numFaseDist + datiDist.getNumFase()); +// } else { +// if (datiDist.getIdRigaStep() > 1) { +// datiDist.setNumFase(datiDist.getNumFase() + 1); +// } +// ordStep.setNumFase(datiDist.getNumFase()); +// } +// if (assPeriodoFase) { +// ordStep.setDataIniz(dataIniz) +// .setDataFine(dataFine); +// } +// ordStep.setNote(datiTecnici); +// +// // Acquisizione ID Attività associato al processo padre +// if (activityCicloProd.size() != 0) { +// for (int i = 0; i < activityCicloProd.size(); i++) { +// if (activityCicloProd.get(i).getNumFase() == numFaseDist) { +// ordStep.setActivityId(activityCicloProd.get(i).getActivityID()); +// } +// } +// } +// ordT.getDtbOrdSteps().add(ordStep); +// } +// } +// rs.close(); +// ps.close(); + } + + private static void addControlliQualità(DtbOrdt ordT, Connection conn, List elencoArticoli) throws SQLException { + + String sql = + "SELECT jtb_cicl_cq.num_fase, " + + " jtb_cicl_cq.controllo, " + + " jtb_cicl_cq.valore_rif, " + + " jtb_cicl_cq.num_rip, " + + " jtb_cicl_cq.tipologia " + + "FROM jtb_cicl_cq " + + "WHERE jtb_cicl_cq.cod_prod = " + UtilityDB.listValueToString(elencoArticoli) + " " + + "ORDER BY jtb_cicl_cq.id_riga "; +// ps = conn.prepareStatement(sql); +// rs = ps.executeQuery(); +// while (rs.next()) { +// int numFase = rs.getInt("num_fase"); +// String controllo = rs.getString("controllo"); +// String valoreRif = rs.getString("valore_rif"); +// int numRip = rs.getInt("num_rip"); +// String tipologia = rs.getString("tipologia"); +// datiDist.setIdRigaContrCQ(datiDist.getIdRigaContrCQ() + 1); +// +// // Inserimento controllo di qualità nell'ordine di lavorazione +// DtbOrdCq ordCQ = new DtbOrdCq(); +// ordCQ.setOperation(OperationType.INSERT); +// ordCQ.setIdRiga(datiDist.getIdRigaContrCQ()); +// ordCQ.setControllo(controllo); +// ordCQ.setValoreRif(valoreRif); +// ordCQ.setNumRip(numRip); +// ordCQ.setNumFase(numFase); +// ordCQ.setTipologia(tipologia); +// if (isRoot) { +// ordCQ.setNumFase(numFase + datiDist.getNumFase()); +// } else { +// ordCQ.setNumFase(numFase); +// } +// if (numFase == 0) { +// ordCQ.setNumFase(numFase); +// } +// ordT.getDtbOrdCq().add(ordCQ); +// } +// rs.close(); +// ps.close(); + } + + private static void addDisegni(DtbOrdt ordT, Connection conn, List elencoArticoli) throws SQLException { + String sql = + " SELECT DISTINCT cod_disegno " + + " FROM jrl_cicl_disegni " + + "WHERE cod_prod IN " + UtilityDB.listValueToString(elencoArticoli) + " " + "ORDER BY cod_disegno "; + + List disegni = UtilityDB.executeSimpleQueryOnlyFirstColumn(conn, sql); + + AtomicInteger index = new AtomicInteger(); + List jrlDisOrd = disegni.stream().map(x -> { + JrlDisOrd disOrd = + new JrlDisOrd() + .setCodDisegno(x) + .setQta(BigDecimal.ONE) + .setRigaOrd(index.getAndIncrement()); + return disOrd; + }).collect(Collectors.toList()); + + if (jrlDisOrd != null && jrlDisOrd.size() > 0 ) + ordT.setJrlDisOrd(jrlDisOrd); + + } + + private static String createTempTableProdotti(Connection conn, List elencoProd) throws SQLException { + String tableName = UtilityDB.defTmpTabName("t1_"); + String query; + query = " CREATE TABLE " + tableName + + " (cod_mart varchar(15) NOT NULL ," + + " cod_col varchar(5) NOT NULL ," + + " cod_tagl varchar(15) NOT NULL ," + + " qta_ord numeric(15,5) NOT NULL ) "; + PreparedStatement ps = conn.prepareStatement(query); + ps.executeUpdate(); + ps.close(); + conn.commit(); + + query = "CREATE INDEX ix_" + tableName + " ON " + tableName + " (cod_mart, cod_col, cod_tagl)"; + Statement cmd = conn.createStatement(); + cmd.execute(query); + conn.commit(); + + for (ElencoProdDTO prod : elencoProd) { + query = "INSERT INTO " + tableName + + " VALUES ( " + UtilityDB.valueToString(prod.getCodProd()) + ", " + + UtilityDB.valueToString(prod.getCodCol()) + ", " + + UtilityDB.valueToString(prod.getCodTagl()) + ", " + + UtilityDB.valueToString(prod.getQtaOrd()) + " ) "; + + ps = conn.prepareStatement(query); + ps.executeUpdate(); + ps.close(); + conn.commit(); + } + return tableName; + } + + public static void generateOrdLav(Connection conn, DtbOrdt dtbOrdt) throws Exception { + // Acquisizione dati testata ordine di produzione + String gestione = dtbOrdt.getGestione(); + Date dataOrd = dtbOrdt.getDataOrd(); + Integer numOrd = dtbOrdt.getNumOrd(); + + OrdProdSetupDTO ordProdSetupDTO = UtilityProduction.retrieveSetup(conn); + List mtbUntMis = getUmProperty(conn); + + // (todo FABIO): gestire in cancellazione ordini lavorazione regola che se si tratta dell'ultimo + // ordine di lavorazione dell'ordine di produzione deve cancellare anche l'ordine di produzione + + // Acquisizione dati configurazioni + boolean assegnaAttivita = ordProdSetupDTO.isAssegnaAttivita(); + String tipoGenerazione = ordProdSetupDTO.getTipoGenerazione(); + + if (UtilityString.isNullOrEmpty(tipoGenerazione) && assegnaAttivita) + throw new Exception("E' necessario specificare la tipologia di generazione attività per poter procedere"); + + + boolean checkDepTerzista = ordProdSetupDTO.isCheckDepTerzista(); + boolean genAutoCommOrdProd = ordProdSetupDTO.isGenAutoCommOrdProd(); + + // Acquisizione dati anagrafici intestatario + boolean isTerzista = false; + + String codAnag = dtbOrdt.getCodAnag(); + String codVdes = dtbOrdt.getCodVdes(); + String codMdep = dtbOrdt.getCodMdep(); + String desCom = "", sql; + if (genAutoCommOrdProd || checkDepTerzista) { + sql = + Query.format( + " select CASE WHEN vtb_dest.destinatario IS NULL THEN gtb_anag.rag_soc ELSE gtb_anag.rag_soc + ' - ' + vtb_dest.destinatario END as descr_com, " + + " Cast(CASE WHEN ISNULL(gtb_anag.part_iva, '') <> ISNULL(azienda.part_iva, '') THEN 1 ELSE 0 END as bit) as is_terzista " + + " from gtb_anag LEFT OUTER JOIN vtb_dest ON gtb_anag.cod_anag = vtb_dest.cod_anag and vtb_dest.cod_vdes = %s," + + "azienda " + + "where gtb_anag.cod_anag = %s", + codVdes, codAnag); + HashMap datiDest = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + if (datiDest != null && datiDest.size() > 0) { + desCom = UtilityHashMap.getValueIfExists(datiDest, "descr_com"); + isTerzista = UtilityHashMap.getValueIfExists(datiDest, "is_terzista"); + } + + + if (checkDepTerzista && isTerzista) { + // Se c'è il check del terzista e il fornitore è un terzista allora + // bisognerà acquisire il deposito del terzista + codMdep = getDepositoTerzista(conn, codAnag, codVdes); + } + } + // Verifica esistenza lavoratore associato all'utente connesso + String codJflav = null; + String userName = dtbOrdt.getUsername(); + if (ordProdSetupDTO.isGenerateLotto()) { + codJflav = getCodJflav(conn, userName, ordProdSetupDTO.getCodJflavDef()); + } + + //Inserisce no_op sulle righe lette dal db e non modificate + Stream.of(dtbOrdt.getDtbOrdr()).filter(x -> x.getLoadedFromDb()).forEach(x -> x.setOperation(OperationType.NO_OP)); + + List dtbOrdr = Stream.of(dtbOrdt.getDtbOrdr()).filter(x -> !x.getLoadedFromDb()).toList(); + String tipoValCosto = ordProdSetupDTO.getTipoValCosto(); + int index = 0; + boolean isFistOrdLav = true; + + for (DtbOrdr row : dtbOrdr) { + boolean existOrd = false; + if (row.getOperation() != OperationType.INSERT) { + sql = + Query.format( + "SELECT cast(count(*) as bit) \n" + + " FROM dtb_ordt \n" + + "WHERE dtb_ordt.gestione_rif = %s AND \n" + + " dtb_ordt.data_ord_rif = %s AND \n" + + " dtb_ordt.num_ord_rif = %s AND \n" + + " dtb_ordt.riga_ord_rif = %s", + row.getGestione(), + row.getDataOrd(), + row.getNumOrd(), + row.getRigaOrd()); + existOrd = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + } + + if (existOrd && row.getOperation() == OperationType.DELETE) { + DtbOrdt ordtDel = new DtbOrdt() + .setGestione(row.getGestioneRif()) + .setDataOrd(row.getDataOrdRif()) + .setNumOrd(row.getNumOrdRif()); + ordtDel.setOperation(row.getOperation()); + row.addOrdLav(ordtDel); + continue; + } + + // Acquisizione dati riga prodotto + String codJfasStart = row.getCodJfas(); + String codJfas = ""; + if (codJfasStart != null) { + String[] elencoFasi = codJfasStart.split("\\|"); + if (elencoFasi.length != 0) { + codJfas = elencoFasi[0]; + } + } + + String codJflavLav = row.getCodJflav(); + userName = checkCodJflav(conn, codJflavLav, userName); + checkCodJcomRequired(conn, ordProdSetupDTO.isCodJcomRequired(), row.getCodMart(), row.getCodJcom()); + + String activityID = dtbOrdt.getActivityId(); + HashMap datiOrdine = null; + boolean existActivity = activityID != null; + if (existOrd && row.getOperation() == OperationType.UPDATE) { + datiOrdine = checkOrdLav(conn, ordProdSetupDTO.isCheckLockProd(), row.getGestione(), row.getDataOrd(), row.getNumOrd(), row.getRigaOrd()); + activityID = UtilityHashMap.getValueIfExists(datiOrdine, "activity_id"); + // Verifica su è stato passato l'operatore dall'esterno + if (codJflavLav == null) { + codJflavLav = UtilityHashMap.getValueIfExists(datiOrdine, "cod_jflav"); + } + } + + String codProd = row.getCodMart(); + String partitaMag = row.getPartitaMag(); + String descrProd = (ordProdSetupDTO.isFlagDescrizDaOrdine() && !UtilityString.isNullOrEmpty(row.getDescrizione()) ? row.getDescrizione() : null); + String descrEstesaProd = (ordProdSetupDTO.isFlagDescrizDaOrdine() && !UtilityString.isNullOrEmpty(row.getDescrizioneEstesa()) ? row.getDescrizioneEstesa() : null); + Date dataCons = row.getDataCons(); + if (codProd != null) { + // Verifica esistenza distinta in anagrafica, se non presente + // blocca la procedura + sql = + Query.format( + "SELECT Cast(count(*) as bit) as exist_art FROM mtb_aart " + "WHERE cod_mart = %s ", + codProd); + + boolean existArt = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + if (!existArt) { + throw new Exception("PRODOTTO " + codProd + " NON PRESENTE IN ANAGRAFICA ARTICOLI"); + } + // Assegnazione partita di magazzino se automatica + if (partitaMag == null) { + assegnaPartitaMag(conn, row, ordProdSetupDTO); + partitaMag = row.getPartitaMag(); + } + + // Acquisizione fase prodotto e verifica esistenza ciclo produttivo + boolean existCicloProd = false; + String codJfasCicl = ""; + HashMap datiCicloProd = getDatiCicloProd(conn, codProd); + if (UtilityHashMap.isPresent(datiCicloProd)) { + codJfasCicl = UtilityHashMap.getValueIfExists(datiCicloProd, "cod_jfas"); + if (ordProdSetupDTO.isGenerateLotto()) { + existCicloProd = UtilityHashMap.getValueIfExists(datiCicloProd, "exist_ciclo_prod"); + } + } + + // Acquisizione dati prodoto da distinta base + BigDecimal qtaProdDist = BigDecimal.ONE; + HashMap datiDistinta = getDatiDistinta(conn, codProd); + boolean existDist = false; + if (UtilityHashMap.isPresent(datiDistinta)) { + existDist = UtilityHashMap.getValueIfExists(datiDistinta, "hasRow"); + + if (existDist) { + if (UtilityString.isNullOrEmpty(descrProd)) + descrProd = UtilityHashMap.getValueIfExists(datiDistinta, "descr_art"); + if (UtilityString.isNullOrEmpty(descrEstesaProd)) + descrEstesaProd = UtilityHashMap.getValueIfExists(datiDistinta, "descr_art_estesa"); + if (UtilityString.isNullOrEmpty(codJfas)) + codJfas = UtilityHashMap.getValueIfExists(datiDistinta, "cod_jfas"); + qtaProdDist = UtilityHashMap.getValueIfExists(datiDistinta, "qta_prod"); + } + } + + // Acquisizione numero ordine di lavorazione da generare ed assegnazione fase di riga + final String gestioneLav = "L"; + Integer numOrdLav; + if (!existOrd) { + numOrdLav = OrderRules.completeNumOrd(conn, gestioneLav, dataOrd, null); + } else { + numOrdLav = UtilityHashMap.getValueIfExists(datiOrdine, "num_ord"); + dataOrd = UtilityHashMap.getValueIfExists(datiOrdine, "data_ord"); + } + + row.setNumOrdRif(numOrdLav); + row.setDataOrdRif(dataOrd); + row.setPartitaMag(partitaMag); + + // Inserimento ordine nel lotto di produzione + if (ordProdSetupDTO.isGenerateLotto() && existCicloProd && !existOrd) { + if (index == 0) { + index++; + String tipoLotto = "P"; + JtbLott jtbLott = new JtbLott() + .setCodJfas(codJfas) + .setDataLotto(dataOrd) + .setTipoLotto(tipoLotto) + .setCodJflav(codJflav); + jtbLott.setOperation(OperationType.INSERT); + dtbOrdt.setJtbLott(jtbLott); + } + JtbLotr lotr = new JtbLotr() + .setGestione(gestioneLav) + .setDataOrd(dataOrd) + .setNumOrd(numOrdLav) + .setIdRiga(0); + lotr.setOperation(OperationType.INSERT); + dtbOrdt.getJtbLott().getJtbLotr().add(lotr); + } + + String untMisProd = row.getUntMis(); + BigDecimal qtaProd = row.getQta(); + BigDecimal rapConv = row.getRapConv(); + BigDecimal valUnt = row.getValUnt(); + Integer rigaOrd = row.getRigaOrd(); + String codJcom = row.getCodJcom(); + + // Generazione automatica nuova commessa + if (genAutoCommOrdProd && UtilityString.isNullOrEmpty(codJcom)) { + String statoCommessa = ordProdSetupDTO.getStatoCommessa(); + String tipoCommessa = ordProdSetupDTO.getTipoCommessa(); + CommessaDTO datiComm = new CommessaDTO() + .setCodAnag(codAnag) + .setGestione(gestioneLav) + .setDataOrd(dataOrd) + .setDataCons(dataCons) + .setDataInizLav(row.getDataInizProd()) + .setNumOrd(numOrdLav) + .setTipoAnag(dtbOrdt.getTipoAnag()) + .setDescrComm(desCom) + .setTipoCommessa(tipoCommessa) + .setStatoCommessa(statoCommessa); + + if (codJcom != null) { + getNextCodJcom(conn, datiComm, ordProdSetupDTO); + assegnaCodJcom(datiComm, row); + codJcom = datiComm.getCodjcom(); + } + } + + // Gestione ID attività: + // Se ID viene passato dall'esterno allora non verrà generato alcuna attività e solo se inserimento verrà aggiornata + // la descrizione specificando gli esterni dell'ordine di produzione generato e il codice di commessa se presente + // Se ID non viene passatto dall'esterno allora se verrà generata la struttura delle attività in base alla tipologia + // di generazione: + // - se per PROCESSO PRODUTTIVO verrà generata la struttura delle attività ugale al ciclo produttivo della distinta + // a cui l'ordine si riferisce e l'ID verrà associato al singolo ordine di lavorazione, ma non all'ordine di produzione + // - se per ORDINE DI PRODUZIONE verrà generato un'unica attività con i dati dell'ordine di produzione e tale ID verrà + // associato all'ordine di produzione ed a tutti gli ordini di lavorazione ad esszo associati + List activityCicloProd = new ArrayList<>(); + if (existActivity && isFistOrdLav && dtbOrdt.getOperation() == OperationType.INSERT) { + List activityList = new ArrayList<>(); + String activityDescription = + String.format("PRODUZIONE N° %s DEL + %s", numOrd, new SimpleDateFormat("yyyy/MM/dd").format(dataOrd)); + StbActivity activity = new StbActivity() + .setActivityId(activityID) + .setCodJcom(codJcom) + .setActivityDescription(activityDescription); + activity.setOperation(OperationType.UPDATE); + activityList.add(activity); + row.setStbActivityList(activityList); + } else { + if (tipoGenerazione.equalsIgnoreCase("PROCESSO PRODUTTIVO") && assegnaAttivita) { + activityID = generateActivity(conn, row, codProd, codJcom, gestioneLav, dataOrd, numOrdLav, userName, activityID, row.getOperation(), activityCicloProd); + } + } + if (isFistOrdLav) { + if (tipoGenerazione.equalsIgnoreCase("ORDINE PRODUZIONE") && !existActivity && assegnaAttivita) { + activityID = generateActivity(conn, row, codProd, codJcom, gestione, dataOrd, numOrd, userName, activityID, dtbOrdt.getOperation(), activityCicloProd); + dtbOrdt.setActivityId(activityID); // Assegna activity_id anche all'ordine di produzione + isFistOrdLav = false; + } + } + // Inserimento dati testa ordine di lavorazione + row.setOrdLav(new ArrayList<>()); + OperationType operation = OperationType.INSERT; + if (existOrd) { + if (row.getOperation() != null) + operation = row.getOperation(); + else + operation = OperationType.UPDATE; + } + DtbOrdt ordT = new DtbOrdt() + .setGestione(gestioneLav) + .setDataOrd(dataOrd) + .setNumOrd(numOrdLav) + .setCodAnag(codAnag) + .setCodVdes(codVdes) + .setCodMdep(codMdep) + .setCodJfas(codJfas) + .setListino(tipoValCosto) + .setCodProd(codProd) + .setDescrizioneProd(descrProd) + .setDescrEstesaProd(descrEstesaProd) + .setPartitaMag(partitaMag) + .setUntMisProd(untMisProd) + .setRapConvProd(rapConv) + .setQtaProd(qtaProd) + .setNumCnfProd(row.getNumCnf()) + .setGestioneRif(row.getGestione()) + .setDataOrdRif(dataOrd) + .setDataConsProd(dataCons) + .setDataInizProd(row.getDataInizProd()) + .setNumOrdRif(row.getNumOrd()) + .setRigaOrdRif(row.getRigaOrd()) + .setCompilatoDa(dtbOrdt.getCompilatoDa()) + .setCodJcom(codJcom) + .setNote(row.getNote()) + .setActivityId(activityID) + .setCodJflav(codJflavLav) + .setColliPedana(row.getColliPedana()) + .setCodTcolUl(row.getCodTcolUl()) + .setCodTcolUi(row.getCodTcolUi()) + .setGeneraOrdLavDaProd(dtbOrdt.isGeneraOrdLavDaProd()); + + String flagAnnulla = "N"; + if (UtilityString.equalsIgnoreCase(row.getFlagEvaso(), "A")) { + flagAnnulla = "S"; + } + ordT.setFlagAnnulla(flagAnnulla); + ordT.setOperation(operation); + ordT.setExecuteRecalc(true); + ordT.setUsername(userName); + + if (partitaMag != null && existOrd) { + List ordiniV = DocOrdRules.getOrdiniV(conn, ordT.getCodProd(), ordT.getPartitaMag()); + ordT.setOrdiniV(ordiniV); + } + + row.getOrdLav().add(ordT); + + // Funzione ricorsiva di esplosione distinta base + if (existDist && !existOrd) { + datiDistinta.put("elenco_fasi", codJfasStart); + datiDistinta.put("data_cons", dataCons); + explodeDist(ordT, conn, row, activityCicloProd, existOrd, ordProdSetupDTO, datiDistinta, mtbUntMis); + + // ----------------------------------------------------------- + // SERVIZI ORDINE DI LAVORAZIONE (SOLO SE DEPOSITO TERZISTA) + // ----------------------------------------------------------- + if (checkDepTerzista) { + List dtbOrds = setSpese(conn, qtaProd, qtaProdDist, codProd); + ordT.getDtbOrds().addAll(dtbOrds); + } + } else { + if (!existOrd) { + insertServizio(conn, codJfas, qtaProd, valUnt, ordT); + + } else { + riproporzionaQtaOrd(conn, gestione, dataOrd, numOrd, rigaOrd, qtaProd, rapConv, ordT); + } + } + } + + if (!ordProdSetupDTO.isDisableTriggerOrdL()) row.setOperation(OperationType.NO_OP); + + } + } + + private static Integer getDurataFase(Connection conn, String codProd) throws Exception { + /*I costi di lavorazione (ex lavorazioni esterne) devono essere esclude */ + String sql = + Query.format( + "SELECT MAX(dbo.f_distgetvaluetype('DD', jtb_dist_clav_dir.duration)) AS durata\n" + + "FROM jtb_dist_mate\n" + + " LEFT OUTER JOIN jtb_dist_clav_dir ON jtb_dist_mate.cod_prod = jtb_dist_clav_dir.cod_prod\n" + + " AND jtb_dist_mate.num_fase = jtb_dist_clav_dir.num_fase\n" + + " AND jtb_dist_clav_dir.cod_jfas IS NOT NULL\n" + + "WHERE jtb_dist_mate.cod_prod = %s", codProd); + + return UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + } + + private static List getUmProperty(Connection conn) throws Exception { + String sql = "SELECT * FROM mtb_unt_mis"; + return UtilityDB.executeSimpleQueryDTO(conn, sql, MtbUntMis.class); + } + + private static void insertServizio(Connection conn, String codJfas, BigDecimal qtaProd, BigDecimal valUnt, DtbOrdt ordT) throws SQLException { + String sql; + // ----------------------------------------------------------------------------------------- + // Se l'articolo non ha distinta allora viene generato un ordine di lavorazione con in + // testata l'articolo e la quantità e senza righe di materiali, ma con codice servizio + // uguale al codice fase di lavorazione ove presente + // ----------------------------------------------------------------------------------------- + sql = + "SELECT descrizione, " + + " unt_mis, " + + " cod_aliq " + + "FROM gtb_spes " + + "WHERE gtb_spes.cod_spes = " + UtilityDB.valueToString(codJfas); + + HashMap datiSpese = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + + if (UtilityHashMap.isPresent(datiSpese)) { + String descrServ = UtilityHashMap.getValueIfExists(datiSpese, "descrizione"); + String untMisServ = UtilityHashMap.getValueIfExists(datiSpese, "unt_mis"); + + // Calcolo periodo periodo lavorazione per ogni fase del ciclo produttivo + + // Inserimento riga servizio nell'ordine di lavorazione + DtbOrds ordS = new DtbOrds(); + ordS.setOperation(OperationType.INSERT); + ordS.setCodSpes(codJfas); + ordS.setUntMis(untMisServ); + ordS.setDescrizione(descrServ); + ordS.setQta(qtaProd); + ordS.setValUnt(valUnt); + ordS.setIdRiga(1); + ordT.getDtbOrds().add(ordS); + } + } + + private static void riproporzionaQtaOrd(Connection conn, String gestione, Date dataOrd, Integer numOrd, Integer rigaOrd, BigDecimal qtaProd, BigDecimal rapConv, DtbOrdt ordT) throws SQLException, IllegalAccessException, DataConverterNotFoundException, InstantiationException { + String sql; + sql = + Query.format( + "SELECT qta_prod*rap_conv_prod as qta_prod " + + " FROM dtb_ordt " + + " WHERE dtb_ordt.gestione_rif = %s AND " + + " dtb_ordt.data_ord_rif = %s AND " + + " dtb_ordt.num_ord_rif = %s AND " + + " dtb_ordt.riga_ord_rif = %s", + gestione, + dataOrd, + numOrd, + rigaOrd); + + BigDecimal qtaProdOld = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + BigDecimal qtaProdNew = qtaProd.multiply(rapConv); + BigDecimal moltiplicatore = qtaProdNew.divide(qtaProdOld, 5); + + if (!moltiplicatore.equals(BigDecimal.ONE)) { + sql = "SELECT * FROM dtb_ordr"; + sql = UtilityDB.addwhereCond(sql, ordT.getPkWhereCond(), true); + List dtbOrdrL = UtilityDB.executeSimpleQueryDTO(conn, sql, DtbOrdr.class); + + dtbOrdrL.stream().forEach(x -> { + x.setQtaOrd(x.getQtaOrd().multiply(moltiplicatore).setScale(2, RoundingMode.HALF_UP)); + x.setOperation(OperationType.UPDATE); + }); + + ordT.setDtbOrdr(dtbOrdrL); + + sql = "SELECT * FROM dtb_ord_steps"; + sql = UtilityDB.addwhereCond(sql, ordT.getPkWhereCond(), true); + List dtbOrdSteps = UtilityDB.executeSimpleQueryDTO(conn, sql, DtbOrdSteps.class); + + dtbOrdSteps.stream().forEach(x -> { + x.setQtaProd(x.getQtaProd().multiply(moltiplicatore).setScale(2, RoundingMode.HALF_UP)); + x.setOperation(OperationType.UPDATE); + }); + + ordT.setDtbOrdSteps(dtbOrdSteps); + } + } + + private static List setSpese(Connection conn, BigDecimal qtaProd, BigDecimal qtaProdDist, String codProd) throws Exception { + String sql; + BigDecimal rapporto = qtaProd.divide(qtaProdDist, EmsRestConstants.cifreDecMax, RoundingMode.HALF_UP); + sql = "SELECT jtb_dist_clav_dir.cod_jcos_dir as cod_spes, " + + " ISNULL(jtb_dist_clav_dir.descrizione, gtb_spes.descrizione) as descrizione, " + + " jtb_dist_clav_dir.unt_mis as unt_mis, " + + " Round(jtb_dist_clav_dir.qta_lav * " + UtilityDB.valueToString(rapporto) + ", 5) as qta, " + + " jtb_dist_clav_dir.val_unt as val_unt " + + "FROM jtb_dist_clav_dir, " + + " jtb_cicl, " + + " gtb_spes " + + "WHERE jtb_dist_clav_dir.cod_jcos_dir = gtb_spes.cod_spes AND " + + " jtb_cicl.cod_prod = jtb_dist_clav_dir.cod_prod AND " + + " jtb_dist_clav_dir.cod_prod = " + UtilityDB.valueToString(codProd) + " AND " + + " jtb_dist_clav_dir.num_fase = 0 AND " + + " jtb_dist_clav_dir.flag_fase_pref = 'S' "; + + List dtbOrds = new ResultSetMapper().mapQuerySetToList(conn, sql, DtbOrds.class, OperationType.INSERT); + return dtbOrds; + } + + private static HashMap getDatiDistinta(Connection conn, String codProd) throws SQLException { + String sql = + "SELECT jtb_cicl.descrizione_prod as descr_art, " + + " jtb_cicl.rap_conv_prod as rap_conv_prod," + + "jtb_cicl.descrizione_estesa as descr_art_estesa," + + " jtb_cicl.cod_jfas, " + + " jtb_cicl.qta_prod as qta_prod, " + + " jtb_cicl.gg_tot as gg_tot, " + + " jtb_cicl.unt_mis_prod, " + + " jtb_cicl.rap_conv_prod, " + + "(select cast(count(*) as bit) from jtb_dist_mate where jtb_dist_mate.cod_prod = jtb_cicl.cod_prod) as hasRow " + + "FROM jtb_cicl " + + "WHERE jtb_cicl.cod_prod = " + UtilityDB.valueToString(codProd); + + HashMap datiDistBase = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + return datiDistBase; + + } + + private static HashMap getDatiCicloProd(Connection conn, String codProd) throws SQLException { + String sql; + sql = "SELECT jtb_cicl.cod_jfas , " + + " Cast(SUM(CASE WHEN jtb_dist_clav_dir.cod_prod IS NOT NULL THEN 1 ELSE 0 END) as BIT) as exist_ciclo_prod" + + " FROM jtb_cicl LEFT OUTER JOIN jtb_dist_clav_dir ON jtb_cicl.cod_prod = jtb_dist_clav_dir.cod_prod AND " + + " jtb_dist_clav_dir.cod_jfas IS NOT NULL " + + "WHERE jtb_cicl.cod_prod = " + UtilityDB.valueToString(codProd) + + "GROUP BY jtb_cicl.cod_jfas"; + + HashMap datiCicloProd = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + return datiCicloProd; + } + + private static HashMap checkOrdLav(Connection conn, boolean checkLockProd, String gestione, Date dataOrd, Integer numOrd, Integer rigaOrd) throws Exception { + // Controllo se l'ordine di lavorazione è stato avviato + String sql = "select distinct " + + " CAST(case when dtb_ordt.flag_evaso_prod = 'E' or dtb_ordt.flag_evaso_forzato = 'S' or ordSteps.prodAvviata <> 0 then 1 else 0 end as bit) as flag_lock, " + + " dtb_ordt.data_ord, " + + " dtb_ordt.num_ord " + + "from (select gestione, data_ord, num_ord " + + " from dtb_ordt " + + " where dtb_ordt.gestione_rif = " + UtilityDB.valueToString(gestione) + " AND " + + " dtb_ordt.data_ord_rif = " + UtilityDB.valueDateToString(dataOrd, CommonConstants.DATE_FORMAT_YMD) + " AND " + + " dtb_ordt.num_ord_rif = " + UtilityDB.valueToString(numOrd) + " AND " + + " dtb_ordt.riga_ord_rif = " + UtilityDB.valueToString(rigaOrd) + ") ordlav, " + + " dtb_ordt, " + + " dtb_ordr, " + + " ( select dtb_ordt.gestione, " + + " dtb_ordt.data_ord, " + + " dtb_ordt.num_ord, " + + " sum(case when id_step <> 0 then 1 else 0 end) as prodAvviata " + + " from dtb_ordt , " + + " dtb_ord_steps " + + " where dtb_ordt.gestione = dtb_ord_steps.gestione and " + + " dtb_ordt.data_ord = dtb_ord_steps.data_ord and " + + " dtb_ordt.num_ord = dtb_ord_steps.num_ord and " + + " dtb_ordt.gestione_rif = " + UtilityDB.valueToString(gestione) + " AND " + + " dtb_ordt.data_ord_rif = " + UtilityDB.valueDateToString(dataOrd, CommonConstants.DATE_FORMAT_YMD) + " AND " + + " dtb_ordt.num_ord_rif = " + UtilityDB.valueToString(numOrd) + " AND " + + " dtb_ordt.riga_ord_rif = " + UtilityDB.valueToString(rigaOrd) + " " + + " group by dtb_ordt.gestione, " + + " dtb_ordt.data_ord, " + + " dtb_ordt.num_ord)ordSteps " + + "where ordLav.gestione = dtb_ordt.gestione and " + + " ordLav.data_ord = dtb_ordt.data_ord and " + + " ordLav.num_ord = dtb_ordt.num_ord and " + + " dtb_ordr.gestione = dtb_ordt.gestione and " + + " dtb_ordr.data_ord = dtb_ordt.data_ord and " + + " dtb_ordr.num_ord = dtb_ordt.num_ord and " + + " dtb_ordt.gestione = ordSteps.gestione and " + + " dtb_ordt.data_ord = ordSteps.data_ord and " + + " dtb_ordt.num_ord = ordSteps.num_ord"; + + HashMap datiOrdine = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + if (datiOrdine != null && datiOrdine.size() > 0) { + boolean flagLock = UtilityHashMap.getValueIfExists(datiOrdine, "flag_lock"); + Date dataOrdLav = UtilityHashMap.getValueIfExists(datiOrdine, "data_ord"); + Integer numOrdLav = UtilityHashMap.getValueIfExists(datiOrdine, "num_ord"); + if (flagLock && checkLockProd) { + throw new Exception("La produzione num. " + numOrdLav + " del " + (new SimpleDateFormat(CommonConstants.DATE_FORMAT_DMY).format(dataOrdLav)) + " è stata già avviata, non è pertanto possibile apportare modifiche"); + } + } + + // Acquisizione fase da testa ordine di lavorazione + sql = " select cod_jfas, activity_id, cod_jflav from dtb_ordt " + + "WHERE gestione_rif = " + UtilityDB.valueToString(gestione) + " AND " + + " data_ord_rif = " + UtilityDB.valueDateToString(dataOrd, CommonConstants.DATE_FORMAT_YMD) + " AND " + + " num_ord_rif = " + UtilityDB.valueToString(numOrd.toString()) + " AND " + + " riga_ord_rif = " + UtilityDB.valueToString(rigaOrd.toString()); + HashMap dati = UtilityDB.executeSimpleQueryOnlyFirstRow(conn, sql); + if (UtilityHashMap.isPresent(dati)) { + String activityID = UtilityHashMap.getValueIfExists(datiOrdine, "activity_id"); + datiOrdine.put("activity_id", activityID); + String codJflavLav = UtilityHashMap.getValueIfExists(datiOrdine, "cod_jflav"); + datiOrdine.put("cod_jflav", codJflavLav); + } + return datiOrdine; + } + + private static String checkCodJflav(Connection conn, String codJflavLav, String userName) throws Exception { + // Verifica se il codice lavoratore associato alla lavorazione esiste come utente delle attività, + // perchè se viene specificato l'utente che deve effettuare la lavorazione allora l'attività dovrà + // essere assegnata all'utente specificato + + if (codJflavLav != null && !codJflavLav.equals(EmsRestConstants.NULL)) { + String sql = " SELECT user_name " + + " FROM jrl_flav_users " + + "WHERE cod_jflav = " + UtilityDB.valueToString(codJflavLav) + + " AND flag_jflav_default = 'S'"; + + String userNameLav = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + + if (userNameLav == null) { + throw new Exception("Il lavoratore o la squadra " + codJflavLav + " non è abilitato alla gestione delle attività, verificare che l'utente sia stato associato ad un utente di sistema in forza lavoro"); + } + + userName = userNameLav; + } + return userName; + } + + private static void checkCodJcomRequired(Connection conn, boolean codJcomRequired, String codProd, String codJcom) throws Exception { + // Verifica se l'articolo prevede l'obbligo del codice di commessa, in tal caso si blocca la procedura. + // Il campo COD_JCOM_REQUIRED può contenere o S/N se qualsiasi produzione deve avere la specifica della commessa, + // oppure la specifica di una etichetta (Disegni) sui quali prodotti è necessario specificare la commessa + if (!codJcomRequired) { + String sql = + "SELECT cast(count(*) as bit ) as counter" + + " FROM jrl_cicl_disegni, " + + " stb_gest_setup " + + " WHERE stb_gest_setup.gest_name = 'w_pordi_rc' and " + + " stb_gest_setup.section = 'SETUP' and " + + " stb_gest_setup.key_section = 'COD_JCOM_REQUIRED' and " + + " charindex('|' + jrl_cicl_disegni.cod_disegno + '|' , stb_gest_setup.value ) <> 0 AND " + + " jrl_cicl_disegni.cod_prod = " + UtilityDB.valueToString(codProd); + + codJcomRequired = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + } + if (codJcomRequired && (codJcom == null || codJcom.equals(EmsRestConstants.NULL))) + throw new Exception("Il prodotto " + codProd + " prevede il codice commessa obbligatoriamente, impossibile procedere alla generazione dell'ordine di produzione"); + + } + + private static String getDepositoTerzista(Connection conn, String codAnag, String codVdes) throws SQLException { + String sql = + "SELECT cod_mdep\n" + + "FROM ( SELECT ISNULL(cod_mdep, '') AS cod_mdep, cod_vdes \n" + + " FROM mtb_depo\n" + + " WHERE cod_anag = " + UtilityDB.valueToString(codAnag) + "\n" + + " AND (ISNULL(cod_vdes,'') = ISNULL(" + UtilityDB.valueToString(codVdes) + ",''))\n" + + " UNION ALL\n" + + " SELECT ISNULL(cod_mdep, '') AS cod_mdep, cod_vdes \n" + + " FROM mtb_depo\n" + + " WHERE cod_anag = " + UtilityDB.valueToString(codAnag) + " and cod_vdes is NULL ) depos \n" + + " ORDER BY cod_vdes desc "; + + String codMdep = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(conn, sql); + return codMdep; + } + +}