Merge branch 'master' into develop

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<VtbOffr> {
 
     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());
+    }
 }

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<VtbOfft> {
 
     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);

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();
+    }
+
+}

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);
         }
     }
 

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<VtbOfft> exchangeImportedData = retrieveContratti(
+                    exchangeMultiDb.getPrimaryConnection(),
+                    true, false, testataTableName, righeTableName);
+
+            final List<VtbOfft> exchangeUpdatedData = retrieveContratti(
+                    exchangeMultiDb.getPrimaryConnection(),
+                    false, useTempTable, testataTableName, righeTableName);
+
+            List<EquatableEntityInterface> 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<VtbOfft> 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<VtbOfft> testate = exchangeImportDataManagerService.retrieveDataFromExchange(connection, VtbOfft.class,
+                testataTableName, null, retrieveAlreadyImported);
+
+        final List<VtbOffr> 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<String, Object> importedKey = new HashMap<String, Object>() {{
+            put("id_offerta", imported.getIdOfferta());
+        }};
+
+        exchangeImportDataManagerService.updateImportedStatus(connection, tableName, importedKey, useTempTable);
+    }
+
+    private void singleUpdateImported(Connection connection, List<VtbOffr> imported, boolean useTempTable, String tableName) throws Exception {
+        final List<HashMap<String, Object>> importedRowKeys = imported.stream()
+                .map(x -> new HashMap<String, Object>() {{
+                    put("id_offerta", x.getIdOfferta());
+                    put("cod_mart", x.getCodMart());
+                }})
+                .collect(Collectors.toList());
+
+        exchangeImportDataManagerService.updateImportedStatus(connection, tableName, importedRowKeys, useTempTable);
+    }
+}

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;
                     }
 
                 }

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<String, Class<? extends EntityInterface>>() {{
+            put("vtb_offt_vend", VtbOfft.class);
+            put("vtb_offr_vend", VtbOffr.class);
+        }});
 
     }};