diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/VtbOffr.java b/ems-core/src/main/java/it/integry/ems_model/entity/VtbOffr.java index e3da2976e2..4f80b47070 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/VtbOffr.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/VtbOffr.java @@ -4,17 +4,19 @@ import com.fasterxml.jackson.annotation.JsonTypeName; import it.integry.common.var.CommonConstants; import it.integry.ems_model.annotation.*; import it.integry.ems_model.base.EntityBase; -import org.kie.api.definition.type.PropertyReactive; -import java.math.BigDecimal; -import java.util.Date; - +import it.integry.ems_model.base.EquatableEntityInterface; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.kie.api.definition.type.PropertyReactive; + +import java.math.BigDecimal; +import java.util.Date; +import java.util.Objects; @PropertyReactive @Table(VtbOffr.ENTITY) @JsonTypeName(VtbOffr.ENTITY) -public class VtbOffr extends EntityBase { +public class VtbOffr extends EntityBase implements EquatableEntityInterface { private final static Logger logger = LogManager.getLogger(); @@ -315,4 +317,32 @@ public class VtbOffr extends EntityBase { this.qtaFatt = qtaFatt; return this; } + + @Override + public int hashCodeKey() { + return Objects.hash(getIdOfferta(), getCodMart()); + } + + @Override + public boolean equalsKey(VtbOffr other) { + if (this == other) + return true; + + if (hashCodeKey() != other.hashCodeKey()) + return false; + + return Objects.equals(getIdOfferta(), other.getIdOfferta()) && Objects.equals(getCodMart(), other.getCodMart()); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof VtbOffr)) return false; + VtbOffr vtbOffr = (VtbOffr) o; + return Objects.equals(getIdOfferta(), vtbOffr.getIdOfferta()) && Objects.equals(getCodMart(), vtbOffr.getCodMart()) && Objects.equals(getUntMis(), vtbOffr.getUntMis()) && Objects.equals(getDescrizione(), vtbOffr.getDescrizione()) && Objects.equals(getDescrizioneHtml(), vtbOffr.getDescrizioneHtml()) && Objects.equals(getJsonCosti(), vtbOffr.getJsonCosti()) && Objects.equals(getCostoUnt(), vtbOffr.getCostoUnt()) && Objects.equals(getUntMisVend(), vtbOffr.getUntMisVend()) && Objects.equals(getPrzUnt(), vtbOffr.getPrzUnt()) && Objects.equals(getQtaOff(), vtbOffr.getQtaOff()) && Objects.equals(getNote(), vtbOffr.getNote()) && Objects.equals(getQtaCnf(), vtbOffr.getQtaCnf()) && Objects.equals(getDataInizContr(), vtbOffr.getDataInizContr()) && Objects.equals(getDataFineContr(), vtbOffr.getDataFineContr()) && Objects.equals(getCodMartOrig(), vtbOffr.getCodMartOrig()) && Objects.equals(getPercSco1(), vtbOffr.getPercSco1()) && Objects.equals(getPercSco2(), vtbOffr.getPercSco2()) && Objects.equals(getPercSco3(), vtbOffr.getPercSco3()) && Objects.equals(getPercSco4(), vtbOffr.getPercSco4()) && Objects.equals(getRapConv(), vtbOffr.getRapConv()) && Objects.equals(getRapConvVend(), vtbOffr.getRapConvVend()) && Objects.equals(getQtaOrd(), vtbOffr.getQtaOrd()) && Objects.equals(getQtaDoc(), vtbOffr.getQtaDoc()) && Objects.equals(getQtaFatt(), vtbOffr.getQtaFatt()); + } + + @Override + public int hashCode() { + return Objects.hash(getIdOfferta(), getCodMart(), getUntMis(), getDescrizione(), getDescrizioneHtml(), getJsonCosti(), getCostoUnt(), getUntMisVend(), getPrzUnt(), getQtaOff(), getNote(), getQtaCnf(), getDataInizContr(), getDataFineContr(), getCodMartOrig(), getPercSco1(), getPercSco2(), getPercSco3(), getPercSco4(), getRapConv(), getRapConvVend(), getQtaOrd(), getQtaDoc(), getQtaFatt()); + } } diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/VtbOfft.java b/ems-core/src/main/java/it/integry/ems_model/entity/VtbOfft.java index eb302c6164..49d34c733c 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/VtbOfft.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/VtbOfft.java @@ -9,6 +9,7 @@ import it.integry.ems.rules.businessLogic.StoredProcedure; import it.integry.ems.task.TaskExecutorService; import it.integry.ems_model.annotation.*; import it.integry.ems_model.base.EntityBase; +import it.integry.ems_model.base.EquatableEntityInterface; import it.integry.ems_model.entity._enum.IBaseEnum; import it.integry.ems_model.types.OperationType; import it.integry.ems_model.utility.UtilityDB; @@ -20,12 +21,13 @@ import org.kie.api.definition.type.PropertyReactive; import java.util.ArrayList; import java.util.Date; import java.util.List; +import java.util.Objects; @Master @PropertyReactive @Table(VtbOfft.ENTITY) @JsonTypeName(VtbOfft.ENTITY) -public class VtbOfft extends EntityBase { +public class VtbOfft extends EntityBase implements EquatableEntityInterface { private final static Logger logger = LogManager.getLogger(); @@ -226,6 +228,34 @@ public class VtbOfft extends EntityBase { return this; } + @Override + public int hashCodeKey() { + return Objects.hash(getIdOfferta()); + } + + @Override + public boolean equalsKey(VtbOfft other) { + if (this == other) + return true; + + if (hashCodeKey() != other.hashCodeKey()) + return false; + + return Objects.equals(getIdOfferta(), other.getIdOfferta()); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof VtbOfft)) return false; + VtbOfft vtbOfft = (VtbOfft) o; + return Objects.equals(getIdOfferta(), vtbOfft.getIdOfferta()) && Objects.equals(getCodAnag(), vtbOfft.getCodAnag()) && Objects.equals(getDataOff(), vtbOfft.getDataOff()) && Objects.equals(getDataScadOff(), vtbOfft.getDataScadOff()) && getStatoOfferta() == vtbOfft.getStatoOfferta() && Objects.equals(getDataIns(), vtbOfft.getDataIns()) && Objects.equals(getInseritoDa(), vtbOfft.getInseritoDa()) && Objects.equals(getDataUltMod(), vtbOfft.getDataUltMod()) && Objects.equals(getModificatoDa(), vtbOfft.getModificatoDa()) && Objects.equals(getActivityId(), vtbOfft.getActivityId()) && Objects.equals(getCodPaga(), vtbOfft.getCodPaga()) && Objects.equals(getNote(), vtbOfft.getNote()) && Objects.equals(getCodVdes(), vtbOfft.getCodVdes()); + } + + @Override + public int hashCode() { + return Objects.hash(getIdOfferta(), getCodAnag(), getDataOff(), getDataScadOff(), getStatoOfferta(), getDataIns(), getInseritoDa(), getDataUltMod(), getModificatoDa(), getActivityId(), getCodPaga(), getNote(), getCodVdes()); + } + public enum StatoOfferta implements IBaseEnum { IN_ELABORAZIONE(0), IN_APPROVAZIONE(1), APPROVATA(2), COMPLETATA(3); diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeContrattiImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeContrattiImportController.java new file mode 100644 index 0000000000..714afbf093 --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeContrattiImportController.java @@ -0,0 +1,46 @@ +package it.integry.ems.system.exchange.controller; + +import it.integry.common.var.CommonConstants; +import it.integry.ems.javabeans.RequestDataDTO; +import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems.system.exchange.service.ExchangeContrattiImportService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Scope; +import org.springframework.web.bind.annotation.*; + +import javax.servlet.http.HttpServletRequest; + +@RestController +@Scope("request") +@RequestMapping("exchange/contratti/") +public class ExchangeContrattiImportController { + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private ExchangeContrattiImportService exchangeContrattiImportService; + + @Autowired + private RequestDataDTO requestDataDTO; + + + @RequestMapping(value = "importVendita", method = RequestMethod.GET) + public @ResponseBody + ServiceRestResponse importContrattiVendita(HttpServletRequest request, + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam String profileDbExchange) throws Exception { + + try (MultiDBTransactionManager multiDBTransactionManager = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager multiDBTransactionManagerExchange = new MultiDBTransactionManager(profileDbExchange)) { + + exchangeContrattiImportService.importVendita(multiDBTransactionManager, multiDBTransactionManagerExchange, requestDataDTO); + + } + + return ServiceRestResponse.createPositiveResponse(); + } + +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeColliImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeColliImportService.java index d1558a417a..6fedd36b7d 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeColliImportService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeColliImportService.java @@ -82,12 +82,12 @@ public class ExchangeColliImportService { public void internalImport(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb, RequestDataDTO requestDataDTO, - ExchangeImportSchemaManagerService.SchemaType colliSchemaType) throws Exception { + ExchangeImportSchemaManagerService.SchemaType schemaType) throws Exception { boolean useTempTable = true; try { String logType = null; - switch (colliSchemaType) { + switch (schemaType) { case ColliLavorazione: logType = "lavorazione"; break; @@ -98,19 +98,19 @@ public class ExchangeColliImportService { logType = "vendita"; break; } - exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), colliSchemaType, useTempTable); + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), schemaType, useTempTable); String testataTableName; String righeTableName; - if (colliSchemaType == ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione) { + if (schemaType == ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione) { testataTableName = "mtb_colt_lav"; righeTableName = "mtb_colr_lav"; - } else if (colliSchemaType == ExchangeImportSchemaManagerService.SchemaType.VersamentoGrezzo) { + } else if (schemaType == ExchangeImportSchemaManagerService.SchemaType.VersamentoGrezzo) { testataTableName = "mtb_colt_versamento_grezzo"; righeTableName = "mtb_colr_versamento_grezzo"; - } else if (colliSchemaType == ExchangeImportSchemaManagerService.SchemaType.ColliVendita) { + } else if (schemaType == ExchangeImportSchemaManagerService.SchemaType.ColliVendita) { testataTableName = "mtb_colt_vend"; righeTableName = "mtb_colr_vend"; } else { @@ -119,7 +119,7 @@ public class ExchangeColliImportService { } exchangeImportDataManagerService.prepareData(exchangeMultiDb.getPrimaryConnection(), useTempTable, - exchangeImportSchemaManagerService.getTablesBySchemaType(colliSchemaType)); + exchangeImportSchemaManagerService.getTablesBySchemaType(schemaType)); AtomicInteger dataCount = new AtomicInteger(0); AtomicInteger importedCounter = new AtomicInteger(0); @@ -244,7 +244,7 @@ public class ExchangeColliImportService { if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; } finally { if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), colliSchemaType); + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), schemaType); } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeContrattiImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeContrattiImportService.java new file mode 100644 index 0000000000..f8106c875f --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeContrattiImportService.java @@ -0,0 +1,167 @@ +package it.integry.ems.system.exchange.service; + +import it.integry.ems.javabeans.RequestDataDTO; +import it.integry.ems.service.EntityProcessor; +import it.integry.ems.sync.MultiDBTransaction.Connection; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems.system.exchange.service.structure.ExchangeImportDataManagerService; +import it.integry.ems.system.exchange.service.structure.ExchangeImportSchemaManagerService; +import it.integry.ems_model.base.EquatableEntityInterface; +import it.integry.ems_model.entity.VtbOffr; +import it.integry.ems_model.entity.VtbOfft; +import it.integry.ems_model.exception.EntityException; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.HashMap; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +@Service +public class ExchangeContrattiImportService { + + //TODO: To be remove, only for fast development + private final String EXCHANGE_USER = "EXCHANGE"; + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private EntityProcessor entityProcessor; + + @Autowired + private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; + + @Autowired + private ExchangeImportDataManagerService exchangeImportDataManagerService; + + public void importVendita(MultiDBTransactionManager internalMultiDb, + MultiDBTransactionManager exchangeMultiDb, + RequestDataDTO requestDataDTO) throws Exception { + + this.internalImport(internalMultiDb, exchangeMultiDb, requestDataDTO, ExchangeImportSchemaManagerService.SchemaType.ContrattiVendita); + } + + + public void internalImport(MultiDBTransactionManager internalMultiDb, + MultiDBTransactionManager exchangeMultiDb, + RequestDataDTO requestDataDTO, + ExchangeImportSchemaManagerService.SchemaType schemaType) throws Exception { + boolean useTempTable = true; + + try { + String logType = null; + switch (schemaType) { + case ContrattiVendita: + logType = "vendita"; + break; + } + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), schemaType, useTempTable); + + String testataTableName = null; + String righeTableName = null; + + if (schemaType == ExchangeImportSchemaManagerService.SchemaType.ContrattiVendita) { + testataTableName = "vtb_offt_vend"; + righeTableName = "vtb_offr_vend"; + } + + exchangeImportDataManagerService.prepareData(exchangeMultiDb.getPrimaryConnection(), useTempTable, + exchangeImportSchemaManagerService.getTablesBySchemaType(schemaType)); + + final List exchangeImportedData = retrieveContratti( + exchangeMultiDb.getPrimaryConnection(), + true, false, testataTableName, righeTableName); + + final List exchangeUpdatedData = retrieveContratti( + exchangeMultiDb.getPrimaryConnection(), + false, useTempTable, testataTableName, righeTableName); + + List allData = exchangeImportDataManagerService + .runSync(VtbOfft.class, exchangeImportedData, exchangeUpdatedData); + + + final Exception[] firstExceptionToThrow = {null}; + + AtomicInteger importedCounter = new AtomicInteger(); + + for (EquatableEntityInterface dataToSave : allData) { + logger.debug("Importati {} contratti di " + logType + " di {}", importedCounter.incrementAndGet(), allData.size()); + try { + entityProcessor.processEntity(dataToSave, true, true, EXCHANGE_USER, internalMultiDb, requestDataDTO); + + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (VtbOfft) dataToSave, useTempTable, testataTableName); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), ((VtbOfft) dataToSave).getVtbOffr(), useTempTable, righeTableName); + + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); + } catch (Exception ex) { + internalMultiDb.rollbackAll(); + exchangeMultiDb.commitAll(); + + VtbOfft errorData = (VtbOfft) dataToSave; + Exception newException = new EntityException("Errore durante l'importazione del contratto [" + + "id_offerta: " + errorData.getIdOfferta() + "]", ex); + + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = newException; + logger.error(newException); + } + } + + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), schemaType); + } + } + + + private List retrieveContratti(Connection connection, boolean retrieveAlreadyImported, boolean useTempTable, + String testataOriginalName, String righeOriginalName) throws Exception { + + String testataTableName = testataOriginalName + (useTempTable ? "_tmp" : ""); + String righeTableName = righeOriginalName + (useTempTable ? "_tmp" : ""); + + + final List testate = exchangeImportDataManagerService.retrieveDataFromExchange(connection, VtbOfft.class, + testataTableName, null, retrieveAlreadyImported); + + final List righe = exchangeImportDataManagerService.retrieveDataFromExchange(connection, VtbOffr.class, + righeTableName, null, retrieveAlreadyImported); + + + testate + .parallelStream() + .forEach(x -> { + x.setVtbOffr(righe.parallelStream() + .filter(y -> Objects.hash(x.getIdOfferta()) == Objects.hash(y.getIdOfferta()) && + (Objects.equals(x.getIdOfferta(), y.getIdOfferta()))) + .collect(Collectors.toList())); + }); + + return testate; + } + + + private void singleUpdateImported(Connection connection, VtbOfft imported, boolean useTempTable, String tableName) throws Exception { + final HashMap importedKey = new HashMap() {{ + put("id_offerta", imported.getIdOfferta()); + }}; + + exchangeImportDataManagerService.updateImportedStatus(connection, tableName, importedKey, useTempTable); + } + + private void singleUpdateImported(Connection connection, List imported, boolean useTempTable, String tableName) throws Exception { + final List> importedRowKeys = imported.stream() + .map(x -> new HashMap() {{ + put("id_offerta", x.getIdOfferta()); + put("cod_mart", x.getCodMart()); + }}) + .collect(Collectors.toList()); + + exchangeImportDataManagerService.updateImportedStatus(connection, tableName, importedRowKeys, useTempTable); + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java index da8c3f3043..dbbabed908 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java @@ -195,6 +195,11 @@ public class ExchangeSystemManagerService { final ExchangeOrdiniImportService beanOrdiniVendita = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class); beanOrdiniVendita.importOrdiniVendita(internalDb, exchangeDb, requestDataDTO); break; + + case ContrattiVendita: + final ExchangeContrattiImportService beanContrattiVendita = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeContrattiImportService.class); + beanContrattiVendita.importVendita(internalDb, exchangeDb, requestDataDTO); + break; } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/structure/ExchangeImportSchemaManagerService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/structure/ExchangeImportSchemaManagerService.java index 5f915d5326..82b0710729 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/structure/ExchangeImportSchemaManagerService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/structure/ExchangeImportSchemaManagerService.java @@ -38,7 +38,8 @@ public class ExchangeImportSchemaManagerService { Destinatari(14), DocumentiAcquisto(15), ColliVendita(16), - OrdiniVendita(17); + OrdiniVendita(17), + ContrattiVendita(18); private final int value; @@ -142,6 +143,10 @@ public class ExchangeImportSchemaManagerService { put("dtb_ordt_vend", DtbOrdt.class); put("dtb_ordr_vend", DtbOrdr.class); }}); + put(SchemaType.ContrattiVendita, new HashMap>() {{ + put("vtb_offt_vend", VtbOfft.class); + put("vtb_offr_vend", VtbOffr.class); + }}); }};