Merge branch 'master' into develop

ems-core/src/main/java/it/integry/ems/response/ServiceRestResponse.java

@@ -16,8 +16,8 @@ import it.integry.ems.exception.SyncException;
 import it.integry.ems.json.ResponseJSONObjectMapper;
 import it.integry.ems_model.base.ComposedEntityBase;
 import it.integry.ems_model.base.EntityBase;
-import it.integry.ems_model.exception.EntityException;
 import it.integry.ems_model.types.OperationType;
+import it.integry.ems_model.utility.UtilityException;
 import it.integry.ems_model.utility.UtilityString;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -81,66 +81,16 @@ public class ServiceRestResponse {
 
         this.profileDB = profileDb;
         this.errorType = e.getClass().getCanonicalName();
-        this.errorMessage = e.getMessage();
         if (e instanceof SyncException) {
             profileDB = ((SyncException) e).getProfileDb();
         }
 
-
+        if (e instanceof BaseSystemException) {
-        if (e instanceof NullPointerException) {
+            errorCode = ((BaseSystemException) e).getCode();
-            if(e.getStackTrace().length > 0)
-                this.errorMessage = "Null value at " + e.getStackTrace()[0].toString();
-            else this.errorMessage = "Empty stacktrace\n" + e;
-        } else if (e instanceof BaseSystemException) {
-            this.errorCode = ((BaseSystemException) e).getCode();
-            this.errorMessage = ((BaseSystemException) e).getCustomMessage();
-        } else if (e instanceof EntityException) {
-            EntityException entityException = (EntityException) e;
-
-            boolean isRuntimeException = false;
-            boolean isRuleException = false;
-
-            String message = "";
-
-            //Nel caso sia un errore legato alle regole
-            if (entityException.getInnerException() instanceof RuntimeException) {
-                message += entityException.getInnerException().getCause().getMessage() + "\n";
-                isRuntimeException = true;
-            }
-
-            message += "Impossibile salvare l'entity: " + entityException.getEntityTableName();
-
-            String startMatch = "it.integry.rules.Rule_";
-            String endMatch = "Eval";
-            if (entityException.getInnerException().getMessage().startsWith(startMatch)) {
-                isRuleException = true;
-                String innerMessage = entityException.getInnerException().getMessage();
-                String ruleName = innerMessage.substring(innerMessage.indexOf(startMatch) + startMatch.length(), innerMessage.indexOf(endMatch));
-
-                message += "\nRegola: " + ruleName;
-            }
-
-            if (!isRuntimeException) {
-                message += "\n(" + ((EntityException) e).getInnerException().getMessage() + ")";
-            }
-
-            this.errorMessage = message;
-        } else if (e instanceof RuntimeException) {
-            String message = e.getCause() != null && e.getCause().getMessage() != null ? e.getCause().getMessage() : e.toString();
-
-            String startMatch = "it.integry.rules.Rule_";
-            String endMatch = "Eval";
-
-            if (e.getMessage() != null && e.getMessage().startsWith(startMatch)) {
-                String innerMessage = e.getMessage();
-                String ruleName = innerMessage.substring(innerMessage.indexOf(startMatch) + startMatch.length(), innerMessage.indexOf(endMatch));
-
-                message += "\nRegola: " + ruleName;
-            }
-
-            this.errorMessage = message;
         }
 
+        this.errorMessage = UtilityException.convertExceptionToHumanReadableText(e);
+
         if (!UtilityString.isNullOrEmpty(this.profileDB))
             this.errorMessage += " (" + this.profileDB + ")";
     }
@@ -332,7 +282,7 @@ public class ServiceRestResponse {
     }
 
     @JsonIgnore
-    public <T>T getDTO(TypeReference<T> type) throws IOException {
+    public <T> T getDTO(TypeReference<T> type) throws IOException {
         ObjectMapper objectMapper = new ResponseJSONObjectMapper();
 
         StringWriter writer = new StringWriter();

ems-core/src/main/java/it/integry/ems_model/utility/UtilityException.java

@@ -0,0 +1,70 @@
+package it.integry.ems_model.utility;
+
+import it.integry.ems.exception.BaseSystemException;
+import it.integry.ems_model.exception.EntityException;
+
+public class UtilityException {
+
+    public static String convertExceptionToHumanReadableText(Exception e) {
+
+        String errorMessage = e.getMessage();;
+        int errorCode = -1;
+
+        if (e instanceof NullPointerException) {
+            if(e.getStackTrace().length > 0)
+                errorMessage = "Null value at " + e.getStackTrace()[0].toString();
+            else errorMessage = "Empty stacktrace\n" + e;
+        } else if (e instanceof BaseSystemException) {
+            errorCode = ((BaseSystemException) e).getCode();
+            errorMessage = ((BaseSystemException) e).getCustomMessage();
+        } else if (e instanceof EntityException) {
+            EntityException entityException = (EntityException) e;
+
+            boolean isRuntimeException = false;
+            boolean isRuleException = false;
+
+            String message = "";
+
+            //Nel caso sia un errore legato alle regole
+            if (entityException.getInnerException() instanceof RuntimeException) {
+                message += entityException.getInnerException().getCause().getMessage() + "\n";
+                isRuntimeException = true;
+            }
+
+            message += "Impossibile salvare l'entity: " + entityException.getEntityTableName();
+
+            String startMatch = "it.integry.rules.Rule_";
+            String endMatch = "Eval";
+            if (entityException.getInnerException().getMessage().startsWith(startMatch)) {
+                isRuleException = true;
+                String innerMessage = entityException.getInnerException().getMessage();
+                String ruleName = innerMessage.substring(innerMessage.indexOf(startMatch) + startMatch.length(), innerMessage.indexOf(endMatch));
+
+                message += "\nRegola: " + ruleName;
+            }
+
+            if (!isRuntimeException) {
+                message += "\n(" + ((EntityException) e).getInnerException().getMessage() + ")";
+            }
+
+            errorMessage = message;
+        } else if (e instanceof RuntimeException) {
+            String message = e.getCause() != null && e.getCause().getMessage() != null ? e.getCause().getMessage() : e.toString();
+
+            String startMatch = "it.integry.rules.Rule_";
+            String endMatch = "Eval";
+
+            if (e.getMessage() != null && e.getMessage().startsWith(startMatch)) {
+                String innerMessage = e.getMessage();
+                String ruleName = innerMessage.substring(innerMessage.indexOf(startMatch) + startMatch.length(), innerMessage.indexOf(endMatch));
+
+                message += "\nRegola: " + ruleName;
+            }
+
+            errorMessage = message;
+        }
+
+        return errorMessage;
+    }
+
+}

ems-engine/src/main/java/it/integry/ems/retail/wms/generic/service/WMSArticoloService.java

@@ -204,6 +204,18 @@ public class WMSArticoloService {
         MtbAart mtbAart = articolo.toMtbAart();
         mtbAart.setOperation(OperationType.INSERT_OR_UPDATE);
 
+        if(UtilityString.isNullOrEmpty(mtbAart.getPartIvaProd())) {
+            String selectCodAliq = "SELECT DISTINCT cod_aliq " +
+                    "FROM " + GtbAliq.ENTITY + " " +
+                    "WHERE perc_aliq = 22";
+
+            String codAliq = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(multiDBTransactionManager.getPrimaryConnection(), selectCodAliq);
+
+            if(!UtilityString.isNullOrEmpty(codAliq)) {
+                mtbAart.setCodAliq(codAliq);
+            }
+        }
+
         if (UtilityString.isNullOrEmpty(mtbAart.getCodMart())) {
             mtbAart.setCodMart(suggestCodMart(mtbAart, articolo.getPrecode()));
         }

ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java

@@ -8,9 +8,12 @@ import it.integry.ems.sync.MultiDBTransaction.AdvancedDataSource;
 import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager;
 import it.integry.ems.system.exchange.service.structure.ExchangeImportSchemaManagerService;
 import it.integry.ems.utility.UtilityDebug;
+import it.integry.ems_model.config.EmsRestConstants;
 import it.integry.ems_model.entity.StbExchangeConfig;
 import it.integry.ems_model.entity.StbExchangeConfigDetail;
+import it.integry.ems_model.types.OperationType;
 import it.integry.ems_model.utility.UtilityDB;
+import it.integry.ems_model.utility.UtilityException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -19,6 +22,9 @@ import org.springframework.scheduling.support.CronTrigger;
 import org.springframework.stereotype.Component;
 import org.springframework.web.context.ContextLoader;
 
+import javax.annotation.Nullable;
+import javax.validation.constraints.NotNull;
+import java.time.LocalDateTime;
 import java.util.HashMap;
 import java.util.List;
 import java.util.concurrent.ScheduledFuture;
@@ -58,6 +64,7 @@ public class ExchangeSystemManagerService {
 
             for (StbExchangeConfig stbExchangeConfig : stbExchangeConfigsToRetrieve) {
                 registerSchedulation(stbExchangeConfig);
+//                break;
             }
         }
 
@@ -85,100 +92,133 @@ public class ExchangeSystemManagerService {
     private void executeExchange(StbExchangeConfig stbExchangeConfig) {
         logger.info("Avvio EXCHANGE [" + stbExchangeConfig.getDescription() + "]");
 
+        StbExchangeConfigDetail executingStbExchangeConfigDetail = null;
 
-        try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(stbExchangeConfig.getInternalProfileDb());
+        try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(stbExchangeConfig.getInternalProfileDb())) {
-             MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(stbExchangeConfig.getExternalProfileDb())) {
+            try (
+                    MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(stbExchangeConfig.getExternalProfileDb())) {
 
-            List<StbExchangeConfigDetail> stbExchangeConfigs = UtilityDB.executeSimpleQueryDTO(internalDb.getPrimaryConnection(),
+                List<StbExchangeConfigDetail> stbExchangeConfigs = UtilityDB.executeSimpleQueryDTO(internalDb.getPrimaryConnection(),
-                    "SELECT * FROM " + StbExchangeConfigDetail.ENTITY + " " +
+                        "SELECT * FROM " + StbExchangeConfigDetail.ENTITY + " " +
-                            " WHERE stb_exchange_config_id = " + stbExchangeConfig.getId() +
+                                " WHERE stb_exchange_config_id = " + stbExchangeConfig.getId() +
-                            " ORDER BY execution_order", StbExchangeConfigDetail.class);
+                                " ORDER BY execution_order", StbExchangeConfigDetail.class);
-            if (stbExchangeConfigs == null) return;
+                if (stbExchangeConfigs == null) return;
 
-            RequestDataDTO requestDataDTO = new RequestDataDTO();
+                RequestDataDTO requestDataDTO = new RequestDataDTO();
-            requestDataDTO.setUsername("EXCHANGE");
+                requestDataDTO.setUsername("EXCHANGE");
 
-            for (StbExchangeConfigDetail stbExchangeConfigDetail : stbExchangeConfigs) {
+                stbExchangeConfig.setLastExecution(LocalDateTime.now())
-                final ExchangeImportSchemaManagerService.SchemaType schemaType = ExchangeImportSchemaManagerService.SchemaType.from(stbExchangeConfigDetail.getConfigType());
+                        .setLastExecutionErrorMessage(EmsRestConstants.NULL)
+                        .setOperation(OperationType.UPDATE);
 
-                switch (schemaType) {
+                stbExchangeConfig.manageWithParentConnection(internalDb.getPrimaryConnection());
-                    case ColliLavorazione:
-                        final ExchangeColliImportService beanColliLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeColliImportService.class);
-                        beanColliLavorazione.importLavorazione(internalDb, exchangeDb, requestDataDTO);
-                        break;
 
-                    case VersamentoGrezzo:
+                for (StbExchangeConfigDetail stbExchangeConfigDetail : stbExchangeConfigs) {
-                        final ExchangeColliImportService beanVersamentoGrezzo = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeColliImportService.class);
+                    executingStbExchangeConfigDetail = stbExchangeConfigDetail;
-                        beanVersamentoGrezzo.importVersamentoGrezzo(internalDb, exchangeDb, requestDataDTO);
+                    final ExchangeImportSchemaManagerService.SchemaType schemaType = ExchangeImportSchemaManagerService.SchemaType.from(stbExchangeConfigDetail.getConfigType());
-                        break;
 
-                    case OrdiniLavorazione:
+                    switch (schemaType) {
-                        final ExchangeOrdiniImportService beanOrdiniLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class);
+                        case ColliLavorazione:
-                        beanOrdiniLavorazione.importOrdiniLavorazione(internalDb, exchangeDb, requestDataDTO);
+                            final ExchangeColliImportService beanColliLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeColliImportService.class);
-                        break;
+                            beanColliLavorazione.importLavorazione(internalDb, exchangeDb, requestDataDTO);
+                            break;
 
-                    case DocumentiLavorazione:
+                        case VersamentoGrezzo:
-                        final ExchangeDocumentImportService beanDocumentiLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
+                            final ExchangeColliImportService beanVersamentoGrezzo = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeColliImportService.class);
-                        beanDocumentiLavorazione.importLavorazione(internalDb, exchangeDb, requestDataDTO);
+                            beanVersamentoGrezzo.importVersamentoGrezzo(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case DocumentiVendita:
+                        case OrdiniLavorazione:
-                        final ExchangeDocumentImportService beanDocumentiVendita = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
+                            final ExchangeOrdiniImportService beanOrdiniLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class);
-                        beanDocumentiVendita.importVendita(internalDb, exchangeDb, requestDataDTO);
+                            beanOrdiniLavorazione.importOrdiniLavorazione(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case Articoli:
+                        case DocumentiLavorazione:
-                        final ExchangeArticoliImportService beanArticoli = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeArticoliImportService.class);
+                            final ExchangeDocumentImportService beanDocumentiLavorazione = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
-                        beanArticoli.importArticoli(internalDb, exchangeDb, requestDataDTO);
+                            beanDocumentiLavorazione.importLavorazione(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case PartiteMagazzinoLavorazione:
+                        case DocumentiVendita:
-                        final ExchangePartiteMagazzinoImportService beanPartiteMagazzino = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangePartiteMagazzinoImportService.class);
+                            final ExchangeDocumentImportService beanDocumentiVendita = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
-                        beanPartiteMagazzino.importPartiteMagazzinoLavorazione(internalDb, exchangeDb, requestDataDTO);
+                            beanDocumentiVendita.importVendita(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case CampiRaccolta:
+                        case Articoli:
-                        final ExchangeOrdiniImportService beanCampiRaccolta = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class);
+                            final ExchangeArticoliImportService beanArticoli = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeArticoliImportService.class);
-                        beanCampiRaccolta.importCampiDiRaccolta(internalDb, exchangeDb, requestDataDTO);
+                            beanArticoli.importArticoli(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case Banche:
+                        case PartiteMagazzinoLavorazione:
-                        final ExchangeBancheImportService beanBancheAziendali = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeBancheImportService.class);
+                            final ExchangePartiteMagazzinoImportService beanPartiteMagazzino = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangePartiteMagazzinoImportService.class);
-                        beanBancheAziendali.importBanche(internalDb, exchangeDb, requestDataDTO);
+                            beanPartiteMagazzino.importPartiteMagazzinoLavorazione(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case Clienti:
+                        case CampiRaccolta:
-                        final ExchangeClientiImportService beanClienti = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeClientiImportService.class);
+                            final ExchangeOrdiniImportService beanCampiRaccolta = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class);
-                        beanClienti.importClienti(internalDb, exchangeDb, requestDataDTO);
+                            beanCampiRaccolta.importCampiDiRaccolta(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case Fornitori:
+                        case Banche:
-                        final ExchangeFornitoriImportService beanFornitori = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeFornitoriImportService.class);
+                            final ExchangeBancheImportService beanBancheAziendali = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeBancheImportService.class);
-                        beanFornitori.importFornitori(internalDb, exchangeDb, requestDataDTO);
+                            beanBancheAziendali.importBanche(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case PDCAnag:
+                        case Clienti:
-                        final ExchangePDCContiImportService beanPdcConti = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangePDCContiImportService.class);
+                            final ExchangeClientiImportService beanClienti = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeClientiImportService.class);
-                        beanPdcConti.importContiAnag(internalDb, exchangeDb, requestDataDTO);
+                            beanClienti.importClienti(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
 
-                    case Destinatari:
+                        case Fornitori:
-                        final ExchangeDestinatariImportService beanDestinatari = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDestinatariImportService.class);
+                            final ExchangeFornitoriImportService beanFornitori = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeFornitoriImportService.class);
-                        beanDestinatari.importDestinatari(internalDb, exchangeDb, requestDataDTO);
+                            beanFornitori.importFornitori(internalDb, exchangeDb, requestDataDTO);
-                        break;
+                            break;
+
+                        case PDCAnag:
+                            final ExchangePDCContiImportService beanPdcConti = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangePDCContiImportService.class);
+                            beanPdcConti.importContiAnag(internalDb, exchangeDb, requestDataDTO);
+                            break;
+
+                        case Destinatari:
+                            final ExchangeDestinatariImportService beanDestinatari = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDestinatariImportService.class);
+                            beanDestinatari.importDestinatari(internalDb, exchangeDb, requestDataDTO);
+                            break;
+
+                        case DocumentiAcquisto:
+                            final ExchangeDocumentImportService beanDocumentiAcquisto = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
+                            beanDocumentiAcquisto.importAcquisto(internalDb, exchangeDb, requestDataDTO);
+                            break;
+                    }
 
-                    case DocumentiAcquisto:
-                        final ExchangeDocumentImportService beanDocumentiAcquisto = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeDocumentImportService.class);
-                        beanDocumentiAcquisto.importAcquisto(internalDb, exchangeDb, requestDataDTO);
-                        break;
                 }
-
+            } catch (Exception e) {
+                logger.error("Errore", e);
+                saveErrorLog(internalDb, stbExchangeConfig, executingStbExchangeConfigDetail, e);
+                throw new RuntimeException(e);
+            } finally {
+                logger.info("Fine EXCHANGE [" + stbExchangeConfig.getDescription() + "]");
             }
         } catch (Exception e) {
             logger.error("Errore", e);
             throw new RuntimeException(e);
-        } finally {
+        }
-            logger.info("Fine EXCHANGE [" + stbExchangeConfig.getDescription() + "]");
+
+    }
+
+    private void saveErrorLog(MultiDBTransactionManager internalDb, @NotNull StbExchangeConfig stbExchangeConfig, @Nullable StbExchangeConfigDetail stbExchangeConfigDetail, @NotNull Exception exceptionToLog) {
+        String logMessage = "";
+
+        if (stbExchangeConfigDetail != null) {
+            logMessage = String.format("[Importazione %s]\n", ExchangeImportSchemaManagerService.SchemaType.from(stbExchangeConfigDetail.getConfigType()));
+        }
+
+        logMessage += UtilityException.convertExceptionToHumanReadableText(exceptionToLog);
+
+        stbExchangeConfig.setLastExecutionErrorMessage(logMessage)
+                .setOperation(OperationType.UPDATE);
+        try {
+            stbExchangeConfig.manageWithParentConnection(internalDb.getPrimaryConnection());
+        } catch (Exception e) {
+            logger.error("Errore durante l'aggiornamento dello stato dell'exchange", e);
         }
 
     }