From 8397e7c6aa66bd715fbde0575ad2d92bf11e8826 Mon Sep 17 00:00:00 2001 From: GiuseppeS Date: Wed, 17 Jul 2024 10:21:48 +0200 Subject: [PATCH] Implementata gestione pianificazioni exchange --- .../model/Migration_20240716105445.java | 48 ++++ .../ScheduledOperationHandlerComponent.java | 4 +- .../integry/ems/service/EntityProcessor.java | 64 ++--- .../integry/ems/sync/AsyncHistoryManager.java | 2 +- .../MultiDBTransactionManager.java | 2 +- .../RemoteSynchronizationSetupService.java | 7 +- .../it/integry/ems_model/entity/MtbGrup.java | 24 +- .../it/integry/ems_model/entity/MtbSgrp.java | 15 +- .../ems_model/entity/StbExchangeConfig.java | 136 +++++++++ .../entity/StbExchangeConfigDetail.java | 68 +++++ .../ExchangeArticoliImportController.java | 10 +- .../ExchangeColliImportController.java | 15 +- .../controller/ExchangeConfigController.java | 65 +++++ .../ExchangeDocumentImportController.java | 9 +- .../ExchangeOrdiniImportController.java | 11 +- .../ExchangeArticoliImportService.java | 268 +++++++++++------- .../service/ExchangeColliImportService.java | 215 +++++++------- .../service/ExchangeConfigService.java | 66 +++++ .../ExchangeDocumentImportService.java | 170 ++++++----- .../ExchangeImportSchemaManagerService.java | 45 ++- .../service/ExchangeOrdiniImportService.java | 128 ++++----- ...ExchangePartiteMagazzinoImportService.java | 25 +- .../service/ExchangeSystemManagerService.java | 76 +++++ 23 files changed, 1016 insertions(+), 457 deletions(-) create mode 100644 ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240716105445.java create mode 100644 ems-core/src/main/java/it/integry/ems_model/entity/StbExchangeConfig.java create mode 100644 ems-core/src/main/java/it/integry/ems_model/entity/StbExchangeConfigDetail.java create mode 100644 ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeConfigController.java create mode 100644 ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeConfigService.java create mode 100644 ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java diff --git a/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240716105445.java b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240716105445.java new file mode 100644 index 0000000000..fef1ad7cce --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240716105445.java @@ -0,0 +1,48 @@ +package it.integry.ems.migration.model; + +import it.integry.ems.migration._base.BaseMigration; +import it.integry.ems.migration._base.MigrationModelInterface; + +public class Migration_20240716105445 extends BaseMigration implements MigrationModelInterface { + + @Override + public void up() throws Exception { + if (isHistoryDB()) + return; + + if (existsTable("stb_exchange_config")) + return; + + executeStatement("CREATE TABLE stb_exchange_config\n" + + "(\n" + + " id BIGINT IDENTITY\n" + + " CONSTRAINT stb_exchange_config_pk\n" + + " PRIMARY KEY,\n" + + " description VARCHAR(MAX),\n" + + " internal_profile_db VARCHAR(MAX) NOT NULL,\n" + + " external_profile_db VARCHAR(MAX) NOT NULL,\n" + + " schedulation_cron VARCHAR(MAX) NOT NULL,\n" + + " created_at DATETIME DEFAULT GETDATE() NOT NULL,\n" + + " last_execution DATETIME,\n" + + " last_execution_error_message VARCHAR(MAX)\n" + + ")"); + + executeStatement("CREATE TABLE dbo.stb_exchange_config_detail\n" + + "(\n" + + " id BIGINT IDENTITY\n" + + " CONSTRAINT stb_exchange_config_detail_pk\n" + + " PRIMARY KEY,\n" + + " stb_exchange_config_id BIGINT NOT NULL\n" + + " CONSTRAINT stb_exchange_config_detail_stb_exchange_config_id_fk\n" + + " REFERENCES dbo.stb_exchange_config (id),\n" + + " type INT NOT NULL,\n" + + " execution_order INT DEFAULT 0 NOT NULL\n" + + ")"); + } + + @Override + public void down() throws Exception { + + } + +} \ No newline at end of file diff --git a/ems-core/src/main/java/it/integry/ems/schedule/new_cron_job/service/ScheduledOperationHandlerComponent.java b/ems-core/src/main/java/it/integry/ems/schedule/new_cron_job/service/ScheduledOperationHandlerComponent.java index 6f4ac45acf..e4249f74a8 100644 --- a/ems-core/src/main/java/it/integry/ems/schedule/new_cron_job/service/ScheduledOperationHandlerComponent.java +++ b/ems-core/src/main/java/it/integry/ems/schedule/new_cron_job/service/ScheduledOperationHandlerComponent.java @@ -32,8 +32,8 @@ public class ScheduledOperationHandlerComponent { private final Logger logger = LogManager.getLogger(); - private HashMap> scheduledOperations = new HashMap<>(); - private HashMap directoryWatcherOperations = new HashMap<>(); + private final HashMap> scheduledOperations = new HashMap<>(); + private final HashMap directoryWatcherOperations = new HashMap<>(); public void scheduleOperation(BaseAutomatedOperationDTO operationModel) throws Exception { diff --git a/ems-core/src/main/java/it/integry/ems/service/EntityProcessor.java b/ems-core/src/main/java/it/integry/ems/service/EntityProcessor.java index d992e5d3de..bf09ef46a4 100644 --- a/ems-core/src/main/java/it/integry/ems/service/EntityProcessor.java +++ b/ems-core/src/main/java/it/integry/ems/service/EntityProcessor.java @@ -10,7 +10,6 @@ import it.integry.ems.datasource.DataSource; import it.integry.ems.dto.EntityPermissionsDTO; import it.integry.ems.exception.InvalidPermissionsException; import it.integry.ems.javabeans.RequestDataDTO; -import it.integry.ems.json.ResponseJSONObjectMapper; import it.integry.ems.model.ColumnMetadataDTO; import it.integry.ems.settings.Model.SettingsModel; import it.integry.ems.sync.MultiDBTransaction.AdvancedDataSource; @@ -33,8 +32,8 @@ import org.apache.logging.log4j.Logger; import org.josql.Query; import org.josql.QueryResults; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Service; +import org.springframework.web.context.ContextLoader; import java.io.StringWriter; import java.sql.*; @@ -45,7 +44,6 @@ import java.util.HashMap; import java.util.List; @Service -@Scope("request") public class EntityProcessor { private final Logger logger = LogManager.getLogger(); @@ -59,18 +57,6 @@ public class EntityProcessor { @Autowired private EntityPropertyHolder entityPropertyHolder; - @Autowired - private ResponseJSONObjectMapper jsonObjectMapper; - - @Autowired - private MultiDBTransactionManager mDbTransactManager; - - @Autowired - private RequestDataDTO requestDataDTO; - - @Autowired - private EntityLoggerService entityLoggerService; - @Autowired private EntityLoggerNewService entityLoggerNewService; @@ -78,6 +64,7 @@ public class EntityProcessor { private SettingsModel settingsModel; public T processEntity(EntityInterface entity, MultiDBTransactionManager multiDBTransactionManager) throws Exception { + final RequestDataDTO requestDataDTO = ContextLoader.getCurrentWebApplicationContext().getBean(RequestDataDTO.class); String username = ""; @@ -85,31 +72,35 @@ public class EntityProcessor { username = requestDataDTO.getUsername(); } - return (T) processEntity(entity, true, false, username, multiDBTransactionManager, true, false); + return (T) processEntity(entity, true, false, username, multiDBTransactionManager, requestDataDTO, true, false); } public EntityBase processEntity(EntityInterface entity, boolean skipCommit, MultiDBTransactionManager multiDBTransactionManager) throws Exception { + final RequestDataDTO requestDataDTO = ContextLoader.getCurrentWebApplicationContext().getBean(RequestDataDTO.class); String username = ""; if (requestDataDTO != null && requestDataDTO.isValidUsername()) { username = requestDataDTO.getUsername(); } - return (EntityBase) processEntity(entity, true, skipCommit, username, multiDBTransactionManager, true, false); + return (EntityBase) processEntity(entity, true, skipCommit, username, multiDBTransactionManager, requestDataDTO, true, false); } public EntityBase processEntity(EntityInterface entity, Boolean isSync, boolean skipCommit, String username, MultiDBTransactionManager mdb) throws Exception { - return (EntityBase) processEntity(entity, isSync, skipCommit, username, mdb, true, false); + + final RequestDataDTO requestDataDTO = ContextLoader.getCurrentWebApplicationContext().getBean(RequestDataDTO.class); + return (EntityBase) processEntity(entity, isSync, skipCommit, username, mdb, requestDataDTO, true, false); } public Object processEntity(EntityInterface entity, Boolean isSync, boolean skipCommit, String username, MultiDBTransactionManager mdb, boolean completeEntity) throws Exception { - return processEntity(entity, isSync, skipCommit, username, mdb, completeEntity, false); + final RequestDataDTO requestDataDTO = ContextLoader.getCurrentWebApplicationContext().getBean(RequestDataDTO.class); + return processEntity(entity, isSync, skipCommit, username, mdb, requestDataDTO, completeEntity, false); } /** @@ -126,7 +117,7 @@ public class EntityProcessor { public Object processEntity(EntityInterface entity, Boolean isSync, boolean skipCommit, String username, - MultiDBTransactionManager mdb, + MultiDBTransactionManager mdb, RequestDataDTO requestDataDTO, boolean completeEntity, boolean overrideEntityChildCheck) throws Exception { try { @@ -139,13 +130,13 @@ public class EntityProcessor { entity.setOperation(OperationType.NO_OP); } - if (!overrideEntityChildCheck) this.checkEntityChildsUsage(entity, mdb); + if (!overrideEntityChildCheck) this.checkEntityChildsUsage(entity, mdb, requestDataDTO); - if (settingsModel.isEnablePermissionCheck() && !checkUserPermissions(entity)) + if (settingsModel.isEnablePermissionCheck() && !checkUserPermissions(entity,mdb)) throw new InvalidPermissionsException(); if (entity.getOperation() == OperationType.NO_OP) { - processInternal(entity, isSync, mdb, completeEntity); + processInternal(entity, isSync, mdb, requestDataDTO, completeEntity); } else if (entity.getOperation() == OperationType.SELECT_OBJECT) { return entity.selectAndMergeEntity(mdb.getPrimaryConnection(), (EntityBase) entity); //return entity; @@ -155,7 +146,7 @@ public class EntityProcessor { return entityList; } else { - processInternal(entity, isSync, mdb, completeEntity); + processInternal(entity, isSync, mdb, requestDataDTO, completeEntity); } if (!skipCommit) { @@ -174,7 +165,7 @@ public class EntityProcessor { } - private void checkEntityChildsUsage(EntityInterface entityInterface, MultiDBTransactionManager multiDBTransactionManager) throws Exception { + private void checkEntityChildsUsage(EntityInterface entityInterface, MultiDBTransactionManager multiDBTransactionManager, RequestDataDTO requestDataDTO) throws Exception { boolean isMaster = entityPropertyHolder.isEntityMaster(((EntityBase) entityInterface).getClass());; OperationType operationType = entityInterface.getOperation(); @@ -209,12 +200,12 @@ public class EntityProcessor { } } - private boolean checkUserPermissions(EntityInterface entity) throws Exception { - if (!UtilityUser.checkLocalUserExist(mDbTransactManager, entity.getUsername())) return true; + private boolean checkUserPermissions(EntityInterface entity, MultiDBTransactionManager multiDBTransactionManager) throws Exception { + if (!UtilityUser.checkLocalUserExist(multiDBTransactionManager, entity.getUsername())) return true; - List results = UtilityUser.getUserPermissions(mDbTransactManager, entity.getUsername(), (EntityBase) entity); + List results = UtilityUser.getUserPermissions(multiDBTransactionManager, entity.getUsername(), (EntityBase) entity); - if (results == null || results.size() == 0) return false; + if (results == null || results.isEmpty()) return false; EntityPermissionsDTO firstPermission = results.get(0); @@ -242,7 +233,7 @@ public class EntityProcessor { } - private void processInternal(EntityInterface entity, Boolean isSync, MultiDBTransactionManager multiDBTransactionManager, boolean completeEntity) throws Exception { + private void processInternal(EntityInterface entity, Boolean isSync, MultiDBTransactionManager multiDBTransactionManager, RequestDataDTO requestDataDTO, boolean completeEntity) throws Exception { DataSource currentDs = multiDBTransactionManager.getPrimaryDatasource(); Connection primaryDB = currentDs.getConnection(); String currentProfileDb = currentDs.getProfile(); @@ -415,6 +406,8 @@ public class EntityProcessor { } public List processEntityList(List entities, boolean singleTransaction) throws Exception { + + final MultiDBTransactionManager mDbTransactManager = ContextLoader.getCurrentWebApplicationContext().getBean(MultiDBTransactionManager.class); return processEntityList(entities, null, true, singleTransaction, false, mDbTransactManager, true, false); } @@ -423,10 +416,14 @@ public class EntityProcessor { } public List processEntityList(List entities, boolean isSync, boolean singleTransaction, boolean ordinaSuPriorita) throws Exception { + + final MultiDBTransactionManager mDbTransactManager = ContextLoader.getCurrentWebApplicationContext().getBean(MultiDBTransactionManager.class); return processEntityList(entities, null, isSync, singleTransaction, ordinaSuPriorita, mDbTransactManager, true, false); } public List processEntityList(List entities, String username, boolean isSync, boolean singleTransaction, boolean ordinaSuPriorita) throws Exception { + + final MultiDBTransactionManager mDbTransactManager = ContextLoader.getCurrentWebApplicationContext().getBean(MultiDBTransactionManager.class); return processEntityList(entities, username, isSync, singleTransaction, ordinaSuPriorita, mDbTransactManager, true, false); } @@ -449,6 +446,9 @@ public class EntityProcessor { MultiDBTransactionManager multiDBTransactionManager, boolean completeEntity, boolean overrideEntityChildCheck) throws Exception { + + final RequestDataDTO requestDataDTO = ContextLoader.getCurrentWebApplicationContext().getBean(RequestDataDTO.class); + if (UtilityString.isNullOrEmpty(username) && requestDataDTO != null && requestDataDTO.isValidUsername()) { username = requestDataDTO.getUsername(); } @@ -466,7 +466,7 @@ public class EntityProcessor { EntityBase entity = entities.get(i); entity.setTransactionGroupId(prevTransactionGroupId); try { - EntityBase entityResult = (EntityBase) this.processEntity(entity, isSync, singleTransaction, username, multiDBTransactionManager, completeEntity, overrideEntityChildCheck); + EntityBase entityResult = (EntityBase) this.processEntity(entity, isSync, singleTransaction, username, multiDBTransactionManager, requestDataDTO, completeEntity, overrideEntityChildCheck); prevTransactionGroupId = entity.getTransactionGroupId(); if (entityResult != null) { entityList.add(entityResult); @@ -489,7 +489,7 @@ public class EntityProcessor { } } - mDbTransactManager.commitAll(); + multiDBTransactionManager.commitAll(); return entityList; } diff --git a/ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java b/ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java index 74d812fb40..75e5dda7bd 100644 --- a/ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java +++ b/ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java @@ -57,7 +57,7 @@ public class AsyncHistoryManager { private final AtomicReference> currentlyInExecutionG = new AtomicReference<>(new ArrayList<>()); - @PostContextConstruct + @PostContextConstruct(priority = 20) public void init() { this.looperService.add(this::consumeRetrieveQueue, 10 * 1000, "async-history-read"); this.looperService.add(this::consumeProcessedQueue, 2 * 1000, "async-history-save"); diff --git a/ems-core/src/main/java/it/integry/ems/sync/MultiDBTransaction/MultiDBTransactionManager.java b/ems-core/src/main/java/it/integry/ems/sync/MultiDBTransaction/MultiDBTransactionManager.java index 86af6b6034..14a49f1cf8 100644 --- a/ems-core/src/main/java/it/integry/ems/sync/MultiDBTransaction/MultiDBTransactionManager.java +++ b/ems-core/src/main/java/it/integry/ems/sync/MultiDBTransaction/MultiDBTransactionManager.java @@ -309,7 +309,7 @@ public class MultiDBTransactionManager implements AutoCloseable { } - Optional availableConnectionsModel = Stream.of(SettingsModel.getInstance().getAvailableConnections()) + java.util.Optional availableConnectionsModel = SettingsModel.getInstance().getAvailableConnections().stream() .filter(x -> x.getProfileName().equalsIgnoreCase(profileDb)) .findFirst(); diff --git a/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSynchronizationSetupService.java b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSynchronizationSetupService.java index 4d57aac23e..e42a67af60 100644 --- a/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSynchronizationSetupService.java +++ b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSynchronizationSetupService.java @@ -29,10 +29,7 @@ import org.springframework.stereotype.Service; import javax.validation.constraints.NotNull; import java.io.IOException; import java.sql.SQLException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.stream.Collectors; import static java.util.stream.Collectors.groupingBy; @@ -79,7 +76,7 @@ public class RemoteSynchronizationSetupService { publicationGroups.add(publicationGroupDTO); final List publications = stbPublicationsDetails.stream() - .filter(x -> x.getStbPublicationId() == stbPublication.getId()) + .filter(x -> Objects.equals(x.getStbPublicationId(), stbPublication.getId())) .map(PublicationDTO::fromStbPublicationDetail) .collect(toList()); publicationGroupDTO.setPublications(publications); diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/MtbGrup.java b/ems-core/src/main/java/it/integry/ems_model/entity/MtbGrup.java index ca49a72607..05335e95f8 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/MtbGrup.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/MtbGrup.java @@ -52,64 +52,72 @@ public class MtbGrup extends EntityBase implements EquatableEntityInterface getMtbSgrp() { return mtbSgrp; } - public void setMtbSgrp(List mtbSgrp) { + public MtbGrup setMtbSgrp(List mtbSgrp) { this.mtbSgrp = mtbSgrp; + return this; } public List getMtbSfam() { return mtbSfam; } - public void setMtbSfam(List mtbSfam) { + public MtbGrup setMtbSfam(List mtbSfam) { this.mtbSfam = mtbSfam; + return this; } @Override diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/MtbSgrp.java b/ems-core/src/main/java/it/integry/ems_model/entity/MtbSgrp.java index 5471f88d3e..f1ded737d7 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/MtbSgrp.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/MtbSgrp.java @@ -56,40 +56,45 @@ public class MtbSgrp extends EntityBase implements EquatableEntityInterface stbExchangeConfigDetail = new ArrayList<>(); + + public Long getId() { + return id; + } + + public StbExchangeConfig setId(Long id) { + this.id = id; + return this; + } + + public String getDescription() { + return description; + } + + public StbExchangeConfig setDescription(String description) { + this.description = description; + return this; + } + + public String getInternalProfileDb() { + return internalProfileDb; + } + + public StbExchangeConfig setInternalProfileDb(String internalProfileDb) { + this.internalProfileDb = internalProfileDb; + return this; + } + + public String getExternalProfileDb() { + return externalProfileDb; + } + + public StbExchangeConfig setExternalProfileDb(String externalProfileDb) { + this.externalProfileDb = externalProfileDb; + return this; + } + + public String getSchedulationCron() { + return schedulationCron; + } + + public StbExchangeConfig setSchedulationCron(String schedulationCron) { + this.schedulationCron = schedulationCron; + return this; + } + + public LocalDateTime getCreatedAt() { + return createdAt; + } + + public StbExchangeConfig setCreatedAt(LocalDateTime createdAt) { + this.createdAt = createdAt; + return this; + } + + public LocalDateTime getLastExecution() { + return lastExecution; + } + + public StbExchangeConfig setLastExecution(LocalDateTime lastExecution) { + this.lastExecution = lastExecution; + return this; + } + + public String getLastExecutionErrorMessage() { + return lastExecutionErrorMessage; + } + + public StbExchangeConfig setLastExecutionErrorMessage(String lastExecutionErrorMessage) { + this.lastExecutionErrorMessage = lastExecutionErrorMessage; + return this; + } + + public List getStbExchangeConfigDetail() { + return stbExchangeConfigDetail; + } + + public StbExchangeConfig setStbExchangeConfigDetail(List stbExchangeConfigDetail) { + this.stbExchangeConfigDetail = stbExchangeConfigDetail; + return this; + } + + protected void deleteChilds() throws Exception { + StbExchangeConfigDetail stbExchangeConfigDetail = new StbExchangeConfigDetail(); + stbExchangeConfigDetail.deleteAllEntities(connection, this); + } +} diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/StbExchangeConfigDetail.java b/ems-core/src/main/java/it/integry/ems_model/entity/StbExchangeConfigDetail.java new file mode 100644 index 0000000000..2e8e46286e --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems_model/entity/StbExchangeConfigDetail.java @@ -0,0 +1,68 @@ +package it.integry.ems_model.entity; + +import it.integry.ems_model.annotation.*; +import it.integry.ems_model.base.EntityBase; +import org.kie.api.definition.type.PropertyReactive; +import com.fasterxml.jackson.annotation.JsonTypeName; + +@PropertyReactive() +@Table(value = StbExchangeConfigDetail.ENTITY) +@JsonTypeName(value = StbExchangeConfigDetail.ENTITY) +public class StbExchangeConfigDetail extends EntityBase { + + public final static String ENTITY = "stb_exchange_config_detail"; + + private final static long serialVersionUID = 1L; + + @PK() + @Identity() + @SqlField(value = "id", nullable = false) + private Long id; + + @SqlField(value = "stb_exchange_config_id", nullable = false) + @FK(tableName = StbExchangeConfig.ENTITY, columnName = "id") + @ImportFromParent("id") + private Long stbExchangeConfigId; + + @SqlField(value = "type", nullable = false) + private Integer configType; + + @SqlField(value = "execution_order", nullable = false) + private Integer executionOrder; + + public Long getId() { + return id; + } + + public StbExchangeConfigDetail setId(Long id) { + this.id = id; + return this; + } + + public Long getStbExchangeConfigId() { + return stbExchangeConfigId; + } + + public StbExchangeConfigDetail setStbExchangeConfigId(Long stbExchangeConfigId) { + this.stbExchangeConfigId = stbExchangeConfigId; + return this; + } + + public Integer getConfigType() { + return configType; + } + + public StbExchangeConfigDetail setConfigType(Integer configType) { + this.configType = configType; + return this; + } + + public Integer getExecutionOrder() { + return executionOrder; + } + + public StbExchangeConfigDetail setExecutionOrder(Integer executionOrder) { + this.executionOrder = executionOrder; + return this; + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeArticoliImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeArticoliImportController.java index 7ee6a417c0..e5311c2db5 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeArticoliImportController.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeArticoliImportController.java @@ -2,6 +2,7 @@ package it.integry.ems.system.exchange.controller; import it.integry.common.var.CommonConstants; import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; import it.integry.ems.system.exchange.service.ExchangeArticoliImportService; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -26,9 +27,14 @@ public class ExchangeArticoliImportController { @RequestMapping(value = "import", method = RequestMethod.GET) public @ResponseBody ServiceRestResponse importArticoli(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String configuration) throws Exception { + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam() String profileDbExchange) throws Exception { - exchangeArticoliImportService.importArticoli(); + + try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(profileDbExchange)) { + exchangeArticoliImportService.importArticoli(internalDb, exchangeDb); + } return ServiceRestResponse.createPositiveResponse(); } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeColliImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeColliImportController.java index e6865cb99a..2ac1c5e625 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeColliImportController.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeColliImportController.java @@ -2,6 +2,7 @@ package it.integry.ems.system.exchange.controller; import it.integry.common.var.CommonConstants; import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; import it.integry.ems.system.exchange.service.ExchangeColliImportService; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -26,9 +27,16 @@ public class ExchangeColliImportController { @RequestMapping(value = "importLavorazione", method = RequestMethod.GET) public @ResponseBody ServiceRestResponse importColliLavorazione(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String configuration) throws Exception { + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam() String profileDbExchange) throws Exception { + + try (MultiDBTransactionManager multiDBTransactionManager = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager multiDBTransactionManagerExchange = new MultiDBTransactionManager(profileDbExchange)) { + + exchangeColliImportService.importColliLavorazione(multiDBTransactionManager, multiDBTransactionManagerExchange); + + } - exchangeColliImportService.importColliLavorazione(); return ServiceRestResponse.createPositiveResponse(); } @@ -43,7 +51,8 @@ public class ExchangeColliImportController { @RequestParam(required = false) String codVdes ) throws Exception { LocalDate dataCertificato = LocalDate.parse(dataCert); - return ServiceRestResponse.createPositiveResponse(exchangeColliImportService.getCertificati(codAnag, + return ServiceRestResponse.createPositiveResponse(exchangeColliImportService.getCertificati(configuration, + codAnag, dataCertificato, codMart, codVdes)); diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeConfigController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeConfigController.java new file mode 100644 index 0000000000..5cf8d2c0c6 --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeConfigController.java @@ -0,0 +1,65 @@ +package it.integry.ems.system.exchange.controller; + +import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.settings.Model.AvailableConnectionsModel; +import it.integry.ems.settings.Model.SettingsModel; +import it.integry.ems.system.exchange.service.ExchangeConfigService; +import it.integry.ems.system.exchange.service.ExchangeImportSchemaManagerService; +import it.integry.ems_model.entity.StbExchangeConfig; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Scope; +import org.springframework.web.bind.annotation.*; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.stream.Collectors; + +@RestController +@Scope("request") +@RequestMapping("exchange/configuration/") +public class ExchangeConfigController { + + @Autowired + private ExchangeConfigService exchangeConfigService; + + @Autowired + private SettingsModel settingsModel; + + @RequestMapping(value = "available-profiles", method = RequestMethod.GET) + public ServiceRestResponse retrieveAvailableProfiles( + @RequestParam(defaultValue = "true") boolean onlyInternal) throws Exception { + + return ServiceRestResponse.createPositiveResponse(settingsModel.getAvailableConnections().stream() + .filter(x -> x.getInternalDb() || !onlyInternal) + .map(AvailableConnectionsModel::getProfileName) + .collect(Collectors.toList())); + } + + @RequestMapping(value = "available-types", method = RequestMethod.GET) + public ServiceRestResponse retrieveAvailableTypes() throws Exception { + final HashMap data = new HashMap<>(); + Arrays.stream(ExchangeImportSchemaManagerService.SchemaType.values()) + .forEach(x -> data.put(x.toString(), x.getValue())); + + return ServiceRestResponse.createPositiveResponse(data); + } + + @RequestMapping(value = "retrieve", method = RequestMethod.GET) + public ServiceRestResponse retrieve() throws Exception { + return ServiceRestResponse.createPositiveResponse(exchangeConfigService.retrieveConfigurations()); + } + + + @RequestMapping(value = "insert", method = RequestMethod.POST) + public ServiceRestResponse insert(@RequestBody StbExchangeConfig configToInsert) throws Exception { + exchangeConfigService.addConfiguration(configToInsert); + return ServiceRestResponse.createPositiveResponse(); + } + + + @RequestMapping(value = "{configId}/delete", method = RequestMethod.GET) + public ServiceRestResponse deletePublicationGroup(@PathVariable long configId) throws Exception { + exchangeConfigService.deleteConfiguration(configId); + return ServiceRestResponse.createPositiveResponse(); + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeDocumentImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeDocumentImportController.java index 3dd9cdfd90..d4ef05ef72 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeDocumentImportController.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeDocumentImportController.java @@ -2,6 +2,7 @@ package it.integry.ems.system.exchange.controller; import it.integry.common.var.CommonConstants; import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; import it.integry.ems.system.exchange.service.ExchangeDocumentImportService; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -26,9 +27,13 @@ public class ExchangeDocumentImportController { @RequestMapping(value = "importLavorazione", method = RequestMethod.GET) public @ResponseBody ServiceRestResponse importDocumentiLavorazione(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String configuration) throws Exception { + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam() String profileDbExchange) throws Exception { - exchangeDocumentImportService.importTestateDocumentiLavorazione(); + try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(profileDbExchange)) { + exchangeDocumentImportService.importTestateDocumentiLavorazione(internalDb, exchangeDb); + } return ServiceRestResponse.createPositiveResponse(); } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeOrdiniImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeOrdiniImportController.java index 47643914d5..744ccb10e6 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeOrdiniImportController.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeOrdiniImportController.java @@ -2,6 +2,7 @@ package it.integry.ems.system.exchange.controller; import it.integry.common.var.CommonConstants; import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; import it.integry.ems.system.exchange.service.ExchangeOrdiniImportService; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -23,13 +24,17 @@ public class ExchangeOrdiniImportController { private ExchangeOrdiniImportService exchangeOrdiniImportService; - @RequestMapping(value = "importLavorazione", method = RequestMethod.GET) public @ResponseBody ServiceRestResponse importLavorazione(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String configuration) throws Exception { + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam() String profileDbExchange) throws Exception { - exchangeOrdiniImportService.importOrdiniLavorazione(); + + try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(profileDbExchange)) { + exchangeOrdiniImportService.importOrdiniLavorazione(internalDb, exchangeDb); + } return ServiceRestResponse.createPositiveResponse(); } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeArticoliImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeArticoliImportService.java index bd438f29b8..a29aa555d8 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeArticoliImportService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeArticoliImportService.java @@ -13,7 +13,6 @@ import it.integry.ems_model.utility.UtilityDB; 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.stereotype.Service; import java.sql.Connection; @@ -25,19 +24,14 @@ import java.util.stream.Collectors; @SuppressWarnings("rawtypes") @Service -@Scope("request") public class ExchangeArticoliImportService { //TODO: To be remove, only for fast development - private final String ROSSOGARGANO_EXCHANGE_PROFILEDB = "ROSSO_GARGANO_EXCHANGE"; private final String ROSSOGARGANO_EXCHANGE_USER = "DBA"; @Autowired private EntityProcessor entityProcessor; - @Autowired - private MultiDBTransactionManager multiDBTransactionManager; - @Autowired private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; @@ -46,61 +40,59 @@ public class ExchangeArticoliImportService { private final Logger logger = LogManager.getLogger(); - public void importArticoli() throws Exception { + public void importArticoli(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb) throws Exception { boolean useTempTable = true; - try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(ROSSOGARGANO_EXCHANGE_PROFILEDB)) { - try { - exchangeImportSchemaManagerService.syncSchema(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.Articoli, useTempTable); + try { + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.Articoli, useTempTable); - importGruppiMerceologici(exchangeDb, useTempTable); + importGruppiMerceologici(internalMultiDb, exchangeMultiDb, useTempTable); - final List exchangeImportedData = retrieveArticoli( - exchangeDb.getPrimaryConnection(), - true, false); + final List exchangeImportedData = retrieveArticoli( + exchangeMultiDb.getPrimaryConnection(), + true, false); - final List exchangeUpdatedData = retrieveArticoli( - exchangeDb.getPrimaryConnection(), - false, useTempTable); + final List exchangeUpdatedData = retrieveArticoli( + exchangeMultiDb.getPrimaryConnection(), + false, useTempTable); - List allData = exchangeImportDataManagerService - .runSync(MtbAart.class, exchangeImportedData, exchangeUpdatedData); + List allData = exchangeImportDataManagerService + .runSync(MtbAart.class, exchangeImportedData, exchangeUpdatedData); - allData.stream() - .filter(x -> x.getOperation() == OperationType.INSERT) - .forEach(x -> x.setOperation(OperationType.INSERT_OR_UPDATE)); + allData.stream() + .filter(x -> x.getOperation() == OperationType.INSERT) + .forEach(x -> x.setOperation(OperationType.INSERT_OR_UPDATE)); - final Exception[] firstExceptionToThrow = {null}; + final Exception[] firstExceptionToThrow = {null}; - AtomicInteger importedCounter = new AtomicInteger(); - List calls = new ArrayList<>(); + AtomicInteger importedCounter = new AtomicInteger(); + List calls = new ArrayList<>(); - for (EquatableEntityInterface dataToSave : allData) { + for (EquatableEntityInterface dataToSave : allData) { // calls.add(() -> { - logger.debug("Importati {} di {}", importedCounter.incrementAndGet(), allData.size()); - try { - entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, multiDBTransactionManager); + logger.debug("Importati {} articoli di {}", importedCounter.incrementAndGet(), allData.size()); + try { + entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, internalMultiDb); - singleUpdateImported(exchangeDb.getPrimaryConnection(), (MtbAart) dataToSave, useTempTable); - multiDBTransactionManager.commitAll(); - } catch (Exception ex) { - if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (MtbAart) dataToSave, useTempTable); + internalMultiDb.commitAll(); + } catch (Exception ex) { + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; - logger.error("Errore durante l'importazione del documento", ex); - multiDBTransactionManager.rollbackAll(); - //throw ex; - } + logger.error("Errore durante l'importazione dell'articolo", ex); + internalMultiDb.rollbackAll(); + //throw ex; + } // }); - } + } // UtilityThread.executeParallel(calls); - if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; - } finally { - if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.Articoli); - } + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.Articoli); } } @@ -130,60 +122,133 @@ public class ExchangeArticoliImportService { connection.commit(); } - private void importGruppiMerceologici(MultiDBTransactionManager exchangeDb, boolean useTempTable) throws Exception { - final List exchangeImportedData = retrieveMtbGrup( + private void importGruppiMerceologici(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeDb, boolean useTempTable) throws Exception { + final List exchangeImportedDataMtbGrup = retrieveMtbGrup( exchangeDb.getPrimaryConnection(), true, false); - final List exchangeUpdatedData = retrieveMtbGrup( + final List exchangeImportedDataMtbSgrp = retrieveMtbSgrup( + exchangeDb.getPrimaryConnection(), + true, false); + + final List exchangeImportedDataMtbSfam = retrieveMtbSfam( + exchangeDb.getPrimaryConnection(), + true, false); + + final List exchangeUpdatedDataMtbGrup = retrieveMtbGrup( exchangeDb.getPrimaryConnection(), false, useTempTable); - List allData = exchangeImportDataManagerService - .runSync(MtbGrup.class, exchangeImportedData, exchangeUpdatedData); + final List exchangeUpdatedDataMtbSgrp = retrieveMtbSgrup( + exchangeDb.getPrimaryConnection(), + false, useTempTable); - allData.stream() - .map(x -> (MtbGrup) x) + final List exchangeUpdatedDataMtbSfam = retrieveMtbSfam( + exchangeDb.getPrimaryConnection(), + false, useTempTable); + + + List allMgrpData = exchangeImportDataManagerService + .runSync(MtbGrup.class, exchangeImportedDataMtbGrup, exchangeUpdatedDataMtbGrup); + + List allMsgrpData = exchangeImportDataManagerService + .runSync(MtbSgrp.class, exchangeImportedDataMtbSgrp, exchangeUpdatedDataMtbSgrp); + + List allMsfamData = exchangeImportDataManagerService + .runSync(MtbSfam.class, exchangeImportedDataMtbSfam, exchangeUpdatedDataMtbSfam); + + + allMgrpData.forEach(x -> x.setOperation(x.getOperation() == OperationType.INSERT ? OperationType.INSERT_OR_UPDATE : x.getOperation())); + allMsgrpData.forEach(x -> x.setOperation(x.getOperation() == OperationType.INSERT ? OperationType.INSERT_OR_UPDATE : x.getOperation())); + allMsfamData.forEach(x -> x.setOperation(x.getOperation() == OperationType.INSERT ? OperationType.INSERT_OR_UPDATE : x.getOperation())); + + + allMsgrpData.stream() + .map(x -> (MtbSgrp) x) + .forEach(x -> x.setMtbSfam(allMsfamData.stream() + .map(y -> (MtbSfam) y) + .filter(y -> y.getCodMgrp().equalsIgnoreCase(x.getCodMgrp()) && + y.getCodMsgr().equalsIgnoreCase(x.getCodMsgr())) + .collect(Collectors.toList()))); + + allMsfamData.stream() + .map(x -> (MtbSfam) x) + .filter(x -> allMsgrpData.stream() + .map(y -> (MtbSgrp) y) + .noneMatch(y -> x.getCodMgrp().equalsIgnoreCase(y.getCodMgrp()) && + x.getCodMsgr().equalsIgnoreCase(y.getCodMsgr()))) .forEach(x -> { + MtbSgrp testata = new MtbSgrp() + .setCodMgrp(x.getCodMgrp()) + .setCodMsgr(x.getCodMsgr()); - if (x.getOperation() == OperationType.INSERT) - x.setOperation(OperationType.INSERT_OR_UPDATE); - - x.getMtbSgrp() - .forEach(y -> { - - if (y.getOperation() == OperationType.INSERT) - y.setOperation(OperationType.INSERT_OR_UPDATE); - - y.getMtbSfam().stream() - .filter(z -> z.getOperation() == OperationType.INSERT) - .forEach(z -> z.setOperation(OperationType.INSERT_OR_UPDATE)); - - y.setOperation(OperationType.INSERT_OR_UPDATE); - }); - + testata.setOperation(OperationType.UPDATE); + allMsgrpData.add(testata); }); + allMgrpData.stream() + .map(x -> (MtbGrup) x) + .forEach(x -> x.setMtbSgrp(allMsgrpData.stream() + .map(y -> (MtbSgrp) y) + .filter(y -> y.getCodMgrp().equalsIgnoreCase(x.getCodMgrp())) + .collect(Collectors.toList()))); + + allMsgrpData.stream() + .map(x -> (MtbSgrp) x) + .filter(x -> allMgrpData.stream() + .map(y -> (MtbGrup) y) + .noneMatch(y -> x.getCodMgrp().equalsIgnoreCase(y.getCodMgrp()))) + .forEach(x -> { + MtbGrup testata = new MtbGrup() + .setCodMgrp(x.getCodMgrp()); + + testata.setOperation(OperationType.UPDATE); + allMgrpData.add(testata); + }); + +// allData.stream() +// .map(x -> (MtbGrup) x) +// .forEach(x -> { +// +// if (x.getOperation() == OperationType.INSERT) +// x.setOperation(OperationType.INSERT_OR_UPDATE); +// +// x.getMtbSgrp() +// .forEach(y -> { +// +// if (y.getOperation() == OperationType.INSERT) +// y.setOperation(OperationType.INSERT_OR_UPDATE); +// +// y.getMtbSfam().stream() +// .filter(z -> z.getOperation() == OperationType.INSERT) +// .forEach(z -> z.setOperation(OperationType.INSERT_OR_UPDATE)); +// +// y.setOperation(OperationType.INSERT_OR_UPDATE); +// }); +// +// }); + + final Exception[] firstExceptionToThrow = {null}; AtomicInteger importedCounter = new AtomicInteger(); List calls = new ArrayList<>(); - for (EquatableEntityInterface dataToSave : allData) { + for (EquatableEntityInterface dataToSave : allMgrpData) { // calls.add(() -> { - logger.debug("Importati {} gruppi merceologici di {}", importedCounter.incrementAndGet(), allData.size()); + logger.debug("Importati {} gruppi merceologici di {}", importedCounter.incrementAndGet(), allMgrpData.size()); try { - entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, multiDBTransactionManager); + entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, internalMultiDb); singleUpdateImported(exchangeDb.getPrimaryConnection(), (MtbGrup) dataToSave, useTempTable); - multiDBTransactionManager.commitAll(); + internalMultiDb.commitAll(); } catch (Exception ex) { if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; logger.error("Errore durante l'importazione del gruppo merceologico", ex); - multiDBTransactionManager.rollbackAll(); + internalMultiDb.rollbackAll(); //throw ex; } @@ -197,49 +262,52 @@ public class ExchangeArticoliImportService { private List retrieveMtbGrup(Connection connection, boolean retrieveAlreadyImported, boolean useTempTable) throws Exception { String mtbGrupOriginalTableName = "mtb_grup"; String mtbGrupTableName = mtbGrupOriginalTableName + (useTempTable ? "_tmp" : ""); + + + if (useTempTable) { + UtilityDB.executeStatement(connection, + "INSERT INTO " + mtbGrupTableName + + " SELECT * FROM " + mtbGrupOriginalTableName + ); + } + + + return exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbGrup.class, + mtbGrupTableName, null, retrieveAlreadyImported); + } + + private List retrieveMtbSgrup(Connection connection, boolean retrieveAlreadyImported, boolean useTempTable) throws Exception { String mtbSgrpOriginalTableName = "mtb_sgrp"; String mtbSgrpTableName = mtbSgrpOriginalTableName + (useTempTable ? "_tmp" : ""); + + + if (useTempTable) { + UtilityDB.executeStatement(connection, + "INSERT INTO " + mtbSgrpTableName + + " SELECT * FROM " + mtbSgrpOriginalTableName + ); + } + + + return exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbSgrp.class, + mtbSgrpTableName, null, retrieveAlreadyImported); + } + + private List retrieveMtbSfam(Connection connection, boolean retrieveAlreadyImported, boolean useTempTable) throws Exception { String mtbSfamOriginalTableName = "mtb_sfam"; String mtbSfamTableName = mtbSfamOriginalTableName + (useTempTable ? "_tmp" : ""); if (useTempTable) { UtilityDB.executeStatement(connection, - "INSERT INTO " + mtbGrupTableName + - " SELECT * FROM " + mtbGrupOriginalTableName, - "INSERT INTO " + mtbSgrpTableName + - " SELECT * FROM " + mtbSgrpOriginalTableName, "INSERT INTO " + mtbSfamTableName + " SELECT * FROM " + mtbSfamOriginalTableName ); } - List mtbGrups = exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbGrup.class, - mtbGrupTableName, null, retrieveAlreadyImported); - List mtbSgrps = exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbSgrp.class, - mtbSgrpTableName, null, retrieveAlreadyImported); - List mtbSfams = exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbSfam.class, + + return exchangeImportDataManagerService.retrieveDataFromExchange(connection, MtbSfam.class, mtbSfamTableName, null, retrieveAlreadyImported); - - - mtbSgrps.forEach(mtbSgrp -> { - - mtbSgrp.setMtbSfam(mtbSfams.stream() - .filter(mtbSfam -> mtbSfam.getCodMgrp().equalsIgnoreCase(mtbSgrp.getCodMgrp()) && - mtbSfam.getCodMsgr().equalsIgnoreCase(mtbSgrp.getCodMsgr())) - .collect(Collectors.toList())); - - }); - - mtbGrups.forEach(mtbGrup -> { - - mtbGrup.setMtbSgrp(mtbSgrps.stream() - .filter(mtbSgrp -> mtbSgrp.getCodMgrp().equalsIgnoreCase(mtbGrup.getCodMgrp())) - .collect(Collectors.toList())); - - }); - - return mtbGrups; } 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 1c279aa080..55ee769877 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 @@ -1,6 +1,5 @@ package it.integry.ems.system.exchange.service; -import it.integry.ems.datasource.DataSource; import it.integry.ems.expansion.RunnableThrowable; import it.integry.ems.service.EntityProcessor; import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; @@ -12,16 +11,13 @@ import it.integry.ems_model.entity.MtbColt; import it.integry.ems_model.service.SetupGest; import it.integry.ems_model.utility.Query; import it.integry.ems_model.utility.UtilityDB; +import it.integry.ems_model.utility.UtilityList; import it.integry.ems_model.utility.UtilityLocalDate; -import it.integry.ems_model.utility.UtilityQuery; -import it.integry.ems_model.utility.*; 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.stereotype.Service; -import java.math.BigDecimal; import java.sql.Connection; import java.time.LocalDate; import java.util.ArrayList; @@ -32,18 +28,14 @@ import java.util.stream.Collectors; @SuppressWarnings("rawtypes") @Service -@Scope("request") public class ExchangeColliImportService { - //TODO: To be remove, only for fast development - private final String ROSSOGARGANO_EXCHANGE_PROFILEDB = "ROSSO_GARGANO_EXCHANGE"; + + private final Logger logger = LogManager.getLogger(); @Autowired private EntityProcessor entityProcessor; - @Autowired - private MultiDBTransactionManager multiDBTransactionManager; - @Autowired private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; @@ -53,78 +45,74 @@ public class ExchangeColliImportService { @Autowired private ExchangePartiteMagazzinoImportService exchangePartiteMagazzinoImportService; - private final Logger logger = LogManager.getLogger(); @Autowired private SetupGest setupGest; - public void importColliLavorazione() throws Exception { + public void importColliLavorazione(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb) throws Exception { boolean useTempTable = true; - try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(ROSSOGARGANO_EXCHANGE_PROFILEDB)) { + try { + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione, useTempTable); + exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(internalMultiDb, exchangeMultiDb); - try { - exchangeImportSchemaManagerService.syncSchema(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione, useTempTable); - exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(); + final List exchangeImportedMtbColts = importColliLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + true, false); - final List exchangeImportedMtbColts = importColliLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - true, false); - - List exchangeUpdatedMtbColts = importColliLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - false, useTempTable); + List exchangeUpdatedMtbColts = importColliLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + false, useTempTable); - List importedMtbColts = exchangeImportedMtbColts.stream() - .map(x -> (EquatableEntityInterface) x) - .collect(Collectors.toList()); + List importedMtbColts = exchangeImportedMtbColts.stream() + .map(x -> (EquatableEntityInterface) x) + .collect(Collectors.toList()); - List updatedMtbColts = exchangeUpdatedMtbColts.stream() - .map(x -> (EquatableEntityInterface) x) - .collect(Collectors.toList()); + List updatedMtbColts = exchangeUpdatedMtbColts.stream() + .map(x -> (EquatableEntityInterface) x) + .collect(Collectors.toList()); - List allMtbColts = exchangeImportDataManagerService - .runSync(MtbColt.class, importedMtbColts, updatedMtbColts); + List allMtbColts = exchangeImportDataManagerService + .runSync(MtbColt.class, importedMtbColts, updatedMtbColts); - final Exception[] firstExceptionToThrow = {null}; + final Exception[] firstExceptionToThrow = {null}; - AtomicInteger importedCounter = new AtomicInteger(); - List calls = new ArrayList<>(); + AtomicInteger importedCounter = new AtomicInteger(); + List calls = new ArrayList<>(); - for (EquatableEntityInterface mtbColtToSave : allMtbColts) { + for (EquatableEntityInterface mtbColtToSave : allMtbColts) { // calls.add(() -> { - logger.debug("Importati {} di {}", importedCounter.incrementAndGet(), allMtbColts.size()); - try { - entityProcessor.processEntity(mtbColtToSave, multiDBTransactionManager); + logger.debug("Importati {} di {}", importedCounter.incrementAndGet(), allMtbColts.size()); + try { + entityProcessor.processEntity(mtbColtToSave, internalMultiDb); - singleUpdateImported(exchangeDb.getPrimaryConnection(), (MtbColt) mtbColtToSave, useTempTable); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (MtbColt) mtbColtToSave, useTempTable); - multiDBTransactionManager.commitAll(); - exchangeDb.commitAll(); - } catch (Exception ex) { - if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); + } catch (Exception ex) { + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; - logger.error("Errore durante l'importazione del collo", ex); - //multiDBTransactionManager.rollbackAll(); - //throw ex; - } -// }); + logger.error("Errore durante l'importazione del collo", ex); + //multiDBTransactionManager.rollbackAll(); + //throw ex; } +// }); + } // UtilityThread.executeParallel(calls); - if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; - } finally { - if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione); - } + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.ColliLavorazione); } } @@ -188,65 +176,66 @@ public class ExchangeColliImportService { } - public List getCertificati(String codAnag, LocalDate dataCert, String codMart, String codVdes) throws Exception { - String profileDbExchange = setupGest.getSetup(multiDBTransactionManager.getPrimaryConnection(), "PVM", "PIAN_ACC_ROSSG", "PROFILE_DB_CERT"); + public List getCertificati(String profileDb, String codAnag, LocalDate dataCert, String codMart, String codVdes) throws Exception { + try (MultiDBTransactionManager multiDBTransactionManager = new MultiDBTransactionManager(profileDb)) { - DataSource dsSync = new DataSource(); - dsSync.initialize(profileDbExchange); - multiDBTransactionManager.addConnection(profileDbExchange, dsSync); - Connection conExch = multiDBTransactionManager.getDatabaseDataSource(profileDbExchange).getConnection(); + String profileDbExchange = setupGest.getSetup(multiDBTransactionManager.getPrimaryConnection(), "PVM", "PIAN_ACC_ROSSG", "PROFILE_DB_CERT"); - List listaCert = UtilityDB.executeSimpleQueryDTO( - conExch, - Query.format("SELECT TRIM(cod_anag) AS codAnag,\n" + - " TRIM(rag_soc) AS ragSoc,\n" + - " TRIM(cod_Vdes) AS codVdes,\n" + - " data_cert AS dataCert,\n" + - " CONVERT(NUMERIC(10, 0), num_cert) AS numCert,\n" + - " data_bolla AS dataBolla,\n" + - " TRIM(num_bolla) AS numBolla,\n" + - " TRIM(PMB_TIPO_POMODORO) AS codMart,\n" + - " TRIM(PMB_SEME) AS varieta,\n" + - " TRIM(lotto_fornitore) AS lottoFornitore,\n" + - " CONVERT(NUMERIC(15, 3), peso_lordo_kg) AS pesoLordoKg,\n" + - " CONVERT(NUMERIC(15, 3), peso_netto_kg) AS pesoNettoKg,\n" + - " CONVERT(NUMERIC(15, 3), scarto_kg) AS scartoKg,\n" + - " CONVERT(NUMERIC(15, 3), val_unt) AS valUnt,\n" + - " CONVERT(NUMERIC(10, 0), casse_scaricate) AS casseScaricate,\n" + - " CONVERT(NUMERIC(10, 0), casse_rese) AS casseRese,\n" + - " TRIM(targa_motrice) AS targaMotrice,\n" + - " TRIM(targa_rimorchio) AS targaRimorchio,\n" + - " TRIM(tagliando_pesa) AS tagliandoPesa,\n" + - " data_ora_lordo AS dataOraLordo,\n" + - " CONVERT(NUMERIC(15, 3), sconto8) AS sconto8,\n" + - " cod_vettore AS cod_vvet,\n" + - " vettore AS vettore,\n" + - " CONVERT(NUMERIC(15, 3), PMB_SCARTO_CQ) AS scartoCq\n " + - "FROM s1_Certificati\n" + - "WHERE cod_anag = {}\n" + - " AND data_cert = {}\n" + - " AND PMB_TIPO_POMODORO = {}", codAnag, dataCert, codMart), - CertificatiSinfoOneDTO.class); - String codDtipLavCar = setupGest.getSetup(multiDBTransactionManager.getPrimaryConnection(), "CRUSCOTTO_PRODUZIONE", - "SETUP", - "COD_DTIP_CAR"); + try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(profileDbExchange)) { - List certificatiImportati = UtilityDB.executeSimpleQueryDTO( - multiDBTransactionManager.getPrimaryConnection(), - Query.format("SELECT data_doc,num_doc,ser_doc,cod_dtip,cod_anag \n" + - "from dtb_doct \n" + - " WHERE " + - " cod_dtip = {}" + - " AND cod_anag = {}\n" + - " AND data_doc = {}\n", codDtipLavCar, codAnag, dataCert), - DtbDoct.class); - if (!UtilityList.isNullOrEmpty(certificatiImportati) && ! UtilityList.isNullOrEmpty(listaCert)) { - listaCert = listaCert.stream().filter((CertificatiSinfoOneDTO cert) -> - certificatiImportati.stream().noneMatch(ddt -> ddt.getNumDoc() == cert.getNumCert().intValue()) - ).collect(Collectors.toList()); + List listaCert = UtilityDB.executeSimpleQueryDTO( + exchangeDb.getPrimaryConnection(), + Query.format("SELECT TRIM(cod_anag) AS codAnag,\n" + + " TRIM(rag_soc) AS ragSoc,\n" + + " TRIM(cod_Vdes) AS codVdes,\n" + + " data_cert AS dataCert,\n" + + " CONVERT(NUMERIC(10, 0), num_cert) AS numCert,\n" + + " data_bolla AS dataBolla,\n" + + " TRIM(num_bolla) AS numBolla,\n" + + " TRIM(PMB_TIPO_POMODORO) AS codMart,\n" + + " TRIM(PMB_SEME) AS varieta,\n" + + " TRIM(lotto_fornitore) AS lottoFornitore,\n" + + " CONVERT(NUMERIC(15, 3), peso_lordo_kg) AS pesoLordoKg,\n" + + " CONVERT(NUMERIC(15, 3), peso_netto_kg) AS pesoNettoKg,\n" + + " CONVERT(NUMERIC(15, 3), scarto_kg) AS scartoKg,\n" + + " CONVERT(NUMERIC(15, 3), val_unt) AS valUnt,\n" + + " CONVERT(NUMERIC(10, 0), casse_scaricate) AS casseScaricate,\n" + + " CONVERT(NUMERIC(10, 0), casse_rese) AS casseRese,\n" + + " TRIM(targa_motrice) AS targaMotrice,\n" + + " TRIM(targa_rimorchio) AS targaRimorchio,\n" + + " TRIM(tagliando_pesa) AS tagliandoPesa,\n" + + " data_ora_lordo AS dataOraLordo,\n" + + " CONVERT(NUMERIC(15, 3), sconto8) AS sconto8,\n" + + " cod_vettore AS cod_vvet,\n" + + " vettore AS vettore,\n" + + " CONVERT(NUMERIC(15, 3), PMB_SCARTO_CQ) AS scartoCq\n " + + "FROM s1_Certificati\n" + + "WHERE cod_anag = {}\n" + + " AND data_cert = {}\n" + + " AND PMB_TIPO_POMODORO = {}", codAnag, dataCert, codMart), + CertificatiSinfoOneDTO.class); + String codDtipLavCar = setupGest.getSetup(multiDBTransactionManager.getPrimaryConnection(), "CRUSCOTTO_PRODUZIONE", + "SETUP", + "COD_DTIP_CAR"); + + List certificatiImportati = UtilityDB.executeSimpleQueryDTO( + multiDBTransactionManager.getPrimaryConnection(), + Query.format("SELECT data_doc,num_doc,ser_doc,cod_dtip,cod_anag \n" + + "from dtb_doct \n" + + " WHERE " + + " cod_dtip = {}" + + " AND cod_anag = {}\n" + + " AND data_doc = {}\n", codDtipLavCar, codAnag, dataCert), + DtbDoct.class); + if (!UtilityList.isNullOrEmpty(certificatiImportati) && !UtilityList.isNullOrEmpty(listaCert)) { + listaCert = listaCert.stream().filter((CertificatiSinfoOneDTO cert) -> + certificatiImportati.stream().noneMatch(ddt -> ddt.getNumDoc() == cert.getNumCert().intValue()) + ).collect(Collectors.toList()); + } + + return listaCert; + } } - - return listaCert; } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeConfigService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeConfigService.java new file mode 100644 index 0000000000..bfa7d3a22d --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeConfigService.java @@ -0,0 +1,66 @@ +package it.integry.ems.system.exchange.service; + +import it.integry.ems.service.EntityProcessor; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +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 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.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +@Service +@Scope(value = "request") +public class ExchangeConfigService { + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private MultiDBTransactionManager multiDBTransactionManager; + + @Autowired + private EntityProcessor entityProcessor; + + public List retrieveConfigurations() throws Exception { + + List stbExchangeConfigsToRetrieve = UtilityDB.executeSimpleQueryDTO(multiDBTransactionManager.getPrimaryConnection(), + "SELECT * FROM " + StbExchangeConfig.ENTITY, StbExchangeConfig.class); + if (stbExchangeConfigsToRetrieve == null) return null; + + List stbExchangeConfigsDetailsToRetrieve = UtilityDB.executeSimpleQueryDTO(multiDBTransactionManager.getPrimaryConnection(), + "SELECT * FROM " + StbExchangeConfigDetail.ENTITY, StbExchangeConfigDetail.class); + if (stbExchangeConfigsDetailsToRetrieve == null) stbExchangeConfigsDetailsToRetrieve = new ArrayList<>(); + + + for (StbExchangeConfig stbExchangeConfig : stbExchangeConfigsToRetrieve) { + stbExchangeConfig.getStbExchangeConfigDetail() + .addAll(stbExchangeConfigsDetailsToRetrieve.stream() + .filter(x -> Objects.equals(x.getStbExchangeConfigId(), stbExchangeConfig.getId())) + .collect(Collectors.toList())); + } + + return stbExchangeConfigsToRetrieve; + } + + public void addConfiguration(StbExchangeConfig stbExchangeConfig) throws Exception { + stbExchangeConfig.setOperation(OperationType.INSERT); + entityProcessor.processEntity(stbExchangeConfig, multiDBTransactionManager); + } + + + public void deleteConfiguration(long idToDelete) throws Exception { + StbExchangeConfig stbExchangeConfigToDelete = new StbExchangeConfig() + .setId(idToDelete); + stbExchangeConfigToDelete.setOperation(OperationType.DELETE); + + entityProcessor.processEntity(stbExchangeConfigToDelete, multiDBTransactionManager); + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeDocumentImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeDocumentImportService.java index 11dde19185..37eb4b7e3b 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeDocumentImportService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeDocumentImportService.java @@ -13,7 +13,6 @@ import it.integry.ems_model.utility.UtilityLocalDate; 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.stereotype.Service; import java.sql.Connection; @@ -27,19 +26,14 @@ import java.util.stream.Collectors; @SuppressWarnings("rawtypes") @Service -@Scope("request") public class ExchangeDocumentImportService { //TODO: To be remove, only for fast development - private final String ROSSOGARGANO_EXCHANGE_PROFILEDB = "ROSSO_GARGANO_EXCHANGE"; private final String ROSSOGARGANO_EXCHANGE_USER = "DBA"; @Autowired private EntityProcessor entityProcessor; - @Autowired - private MultiDBTransactionManager multiDBTransactionManager; - @Autowired private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; @@ -51,120 +45,118 @@ public class ExchangeDocumentImportService { private final Logger logger = LogManager.getLogger(); - public void importTestateDocumentiLavorazione() throws Exception { + public void importTestateDocumentiLavorazione(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb) throws Exception { boolean useTempTable = true; - try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(ROSSOGARGANO_EXCHANGE_PROFILEDB)) { - try { - exchangeImportSchemaManagerService.syncSchema(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.DocumentiLavorazione, useTempTable); - exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(); + try { + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.DocumentiLavorazione, useTempTable); + exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(internalMultiDb, exchangeMultiDb); - final List exchangeImportedTestateData = importTestateDocumentiLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - true, false); + final List exchangeImportedTestateData = importTestateDocumentiLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + true, false); - final List exchangeUpdatedTestateData = importTestateDocumentiLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - false, useTempTable); + final List exchangeUpdatedTestateData = importTestateDocumentiLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + false, useTempTable); - final List exchangeImportedRigheData = importRigheDocumentiLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - true, false); + final List exchangeImportedRigheData = importRigheDocumentiLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + true, false); - final List exchangeUpdatedRigheData = importRigheDocumentiLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - false, useTempTable); + final List exchangeUpdatedRigheData = importRigheDocumentiLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + false, useTempTable); - List allTestateData = exchangeImportDataManagerService - .runSync(DtbDoct.class, exchangeImportedTestateData, exchangeUpdatedTestateData); + List allTestateData = exchangeImportDataManagerService + .runSync(DtbDoct.class, exchangeImportedTestateData, exchangeUpdatedTestateData); - List allRigheData = exchangeImportDataManagerService - .runSync(DtbDocr.class, exchangeImportedRigheData, exchangeUpdatedRigheData); + List allRigheData = exchangeImportDataManagerService + .runSync(DtbDocr.class, exchangeImportedRigheData, exchangeUpdatedRigheData); - allTestateData.stream() - .map(x -> (DtbDoct) x) - .forEach(x -> - x.setDtbDocr(allRigheData.stream() - .map(y -> (DtbDocr) y) - .filter(y -> y.getDataDoc().equals(x.getDataDoc()) && - y.getNumDoc().equals(x.getNumDoc()) && - y.getSerDoc().equalsIgnoreCase(x.getSerDoc()) && - y.getCodAnag().equalsIgnoreCase(x.getCodAnag()) && - y.getCodDtip().equalsIgnoreCase(x.getCodDtip())) - .collect(Collectors.toList()))); + allTestateData.stream() + .map(x -> (DtbDoct) x) + .forEach(x -> + x.setDtbDocr(allRigheData.stream() + .map(y -> (DtbDocr) y) + .filter(y -> y.getDataDoc().equals(x.getDataDoc()) && + y.getNumDoc().equals(x.getNumDoc()) && + y.getSerDoc().equalsIgnoreCase(x.getSerDoc()) && + y.getCodAnag().equalsIgnoreCase(x.getCodAnag()) && + y.getCodDtip().equalsIgnoreCase(x.getCodDtip())) + .collect(Collectors.toList()))); - allRigheData.stream() - .map(x -> (DtbDocr) x) - .filter(x -> allTestateData.stream() - .map(y -> (DtbDoct) y) - .noneMatch(y -> x.getCodDtip().equalsIgnoreCase(y.getCodDtip()) && - x.getDataDoc().equals(y.getDataDoc()) && - Objects.equals(x.getNumDoc(), y.getNumDoc()) && - x.getCodAnag().equalsIgnoreCase(y.getCodAnag()) && - x.getSerDoc().equalsIgnoreCase(y.getSerDoc()))) - .forEach(x -> { - DtbDoct testata = new DtbDoct() - .setSerDoc(x.getSerDoc()) - .setDataDoc(x.getDataDoc()) - .setNumDoc(x.getNumDoc()) - .setCodDtip(x.getCodDtip()) - .setCodAnag(x.getCodAnag()); + allRigheData.stream() + .map(x -> (DtbDocr) x) + .filter(x -> allTestateData.stream() + .map(y -> (DtbDoct) y) + .noneMatch(y -> x.getCodDtip().equalsIgnoreCase(y.getCodDtip()) && + x.getDataDoc().equals(y.getDataDoc()) && + Objects.equals(x.getNumDoc(), y.getNumDoc()) && + x.getCodAnag().equalsIgnoreCase(y.getCodAnag()) && + x.getSerDoc().equalsIgnoreCase(y.getSerDoc()))) + .forEach(x -> { + DtbDoct testata = new DtbDoct() + .setSerDoc(x.getSerDoc()) + .setDataDoc(x.getDataDoc()) + .setNumDoc(x.getNumDoc()) + .setCodDtip(x.getCodDtip()) + .setCodAnag(x.getCodAnag()); - testata.setOperation(OperationType.UPDATE); - allTestateData.add(testata); - }); + testata.setOperation(OperationType.UPDATE); + allTestateData.add(testata); + }); - List allData = allTestateData; + List allData = allTestateData; - final Exception[] firstExceptionToThrow = {null}; + final Exception[] firstExceptionToThrow = {null}; - AtomicInteger importedCounter = new AtomicInteger(); - List calls = new ArrayList<>(); + AtomicInteger importedCounter = new AtomicInteger(); + List calls = new ArrayList<>(); - for (EquatableEntityInterface dataToSave : allData) { + for (EquatableEntityInterface dataToSave : allData) { // calls.add(() -> { - logger.debug("Importati {} di {}", importedCounter.incrementAndGet(), allData.size()); - try { - entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, multiDBTransactionManager); + logger.debug("Importati {} di {}", importedCounter.incrementAndGet(), allData.size()); + try { + entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, internalMultiDb); - singleUpdateImported(exchangeDb.getPrimaryConnection(), (DtbDoct) dataToSave, useTempTable); - //multiDBTransactionManager.commitAll(); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (DtbDoct) dataToSave, useTempTable); + //multiDBTransactionManager.commitAll(); - multiDBTransactionManager.commitAll(); - exchangeDb.commitAll(); - } catch (Exception ex) { - if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); + } catch (Exception ex) { + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; - logger.error("Errore durante l'importazione del documento", ex); - //multiDBTransactionManager.rollbackAll(); - //throw ex; - } + logger.error("Errore durante l'importazione del documento", ex); + //multiDBTransactionManager.rollbackAll(); + //throw ex; + } // }); - } + } // UtilityThread.executeParallel(calls); - if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; - } finally { - if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.DocumentiLavorazione); - } + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.DocumentiLavorazione); } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java index f46eda0dab..9391a286e6 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java @@ -1,10 +1,12 @@ package it.integry.ems.system.exchange.service; +import com.fasterxml.jackson.annotation.JsonValue; import it.integry.ems.entity_logger.db_schema_manager.component.SQLServerDBSchemaManager; import it.integry.ems.entity_logger.db_schema_manager.dto.DatabaseTable; import it.integry.ems.entity_logger.db_schema_manager.dto.DatabaseTableColumn; import it.integry.ems.entity_logger.db_schema_manager.dto.DatabaseTableView; import it.integry.ems.entity_logger.db_schema_manager.dto.DatabaseView; +import it.integry.ems_model.entity._enum.IBaseEnum; import org.springframework.stereotype.Service; import java.sql.Connection; @@ -18,14 +20,45 @@ import java.util.stream.Collectors; public class ExchangeImportSchemaManagerService { - public enum SchemaType { - ColliLavorazione, - OrdiniLavorazione, - DocumentiLavorazione, - Articoli, - PartiteMagazzinoLavorazione + public enum SchemaType implements IBaseEnum { + ColliLavorazione(1), + OrdiniLavorazione(2), + DocumentiLavorazione(3), + Articoli(4), + PartiteMagazzinoLavorazione(5); + + private final int value; + + SchemaType(int value) { + this.value = value; + } + + public static SchemaType from(Object value) { + int castValue = (int) value; + for (SchemaType b : SchemaType.values()) { + if (b.value == castValue) + return b; + } + return null; + } + + @JsonValue + public int getValue() { + return this.value; + } + + @Override + public Object get() { + return this.value; + } + + @Override + public Object fromInternal(Object val) { + return from(val); + } } + private final HashMap> schemaToTableBinding = new HashMap>() {{ put(SchemaType.ColliLavorazione, Arrays.asList("mtb_colt_lav", "mtb_colr_lav")); put(SchemaType.OrdiniLavorazione, Arrays.asList("dtb_ordt_lav", "dtb_ordr_lav")); diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeOrdiniImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeOrdiniImportService.java index 15a535a564..94213c086d 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeOrdiniImportService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeOrdiniImportService.java @@ -14,7 +14,6 @@ import it.integry.ems_model.utility.UtilityLocalDate; 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.stereotype.Service; import java.sql.Connection; @@ -28,20 +27,13 @@ import java.util.stream.Collectors; @SuppressWarnings("rawtypes") @Service -@Scope("request") public class ExchangeOrdiniImportService { - //TODO: To be remove, only for fast development - private final String ROSSOGARGANO_EXCHANGE_PROFILEDB = "ROSSO_GARGANO_EXCHANGE"; - private final Logger logger = LogManager.getLogger(); @Autowired private EntityProcessor entityProcessor; - @Autowired - private MultiDBTransactionManager multiDBTransactionManager; - @Autowired private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; @@ -51,90 +43,88 @@ public class ExchangeOrdiniImportService { @Autowired private ExchangePartiteMagazzinoImportService exchangePartiteMagazzinoImportService; - public void importOrdiniLavorazione() throws Exception { + public void importOrdiniLavorazione(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb) throws Exception { boolean useTempTable = true; - try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(ROSSOGARGANO_EXCHANGE_PROFILEDB)) { - try { - exchangeImportSchemaManagerService.syncSchema(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.OrdiniLavorazione, useTempTable); - exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(); + try { + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.OrdiniLavorazione, useTempTable); + exchangePartiteMagazzinoImportService.importPartiteMagazzinoLavorazione(internalMultiDb, exchangeMultiDb); - final List exchangeImportedMtbColts = importOrdiniLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - true, false); + final List exchangeImportedMtbColts = importOrdiniLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + true, false); - final List exchangeUpdatedMtbColts = importOrdiniLavorazione( - exchangeDb.getPrimaryConnection(), - UtilityLocalDate.getNow().minusWeeks(1), - UtilityLocalDate.getNow(), - false, useTempTable); + final List exchangeUpdatedMtbColts = importOrdiniLavorazione( + exchangeMultiDb.getPrimaryConnection(), + UtilityLocalDate.getNow().minusWeeks(1), + UtilityLocalDate.getNow(), + false, useTempTable); - List allData = exchangeImportDataManagerService - .runSync(DtbOrdt.class, exchangeImportedMtbColts, exchangeUpdatedMtbColts); + List allData = exchangeImportDataManagerService + .runSync(DtbOrdt.class, exchangeImportedMtbColts, exchangeUpdatedMtbColts); - allData.stream() - .map(x -> (DtbOrdt) x) - .filter(x -> x.getGestione().equalsIgnoreCase("L") && - (x.getOperation() == OperationType.INSERT_OR_UPDATE || x.getOperation() == OperationType.INSERT)) - .forEach(x -> { - DtbOrdSteps ordStep = - new DtbOrdSteps() - .setIdRiga(0) - .setCodJfas(x.getCodJfas()) - .setQtaProd(x.getQtaProd()); + allData.stream() + .map(x -> (DtbOrdt) x) + .filter(x -> x.getGestione().equalsIgnoreCase("L") && + (x.getOperation() == OperationType.INSERT_OR_UPDATE || x.getOperation() == OperationType.INSERT)) + .forEach(x -> { + DtbOrdSteps ordStep = + new DtbOrdSteps() + .setIdRiga(0) + .setCodJfas(x.getCodJfas()) + .setQtaProd(x.getQtaProd()); - ordStep.setOperation(OperationType.INSERT_OR_UPDATE); - x.getDtbOrdSteps().add(ordStep); - }); + ordStep.setOperation(OperationType.INSERT_OR_UPDATE); + x.getDtbOrdSteps().add(ordStep); + }); - List> splittedOrders = - Arrays.asList( - allData.stream().filter(x -> ((DtbOrdt) x).getGestione().equalsIgnoreCase("A")).collect(Collectors.toList()), - allData.stream().filter(x -> !((DtbOrdt) x).getGestione().equalsIgnoreCase("A")).collect(Collectors.toList()) - ); + List> splittedOrders = + Arrays.asList( + allData.stream().filter(x -> ((DtbOrdt) x).getGestione().equalsIgnoreCase("A")).collect(Collectors.toList()), + allData.stream().filter(x -> !((DtbOrdt) x).getGestione().equalsIgnoreCase("A")).collect(Collectors.toList()) + ); - final Exception[] firstExceptionToThrow = {null}; + final Exception[] firstExceptionToThrow = {null}; - final AtomicInteger[] importedCounter = {new AtomicInteger()}; + final AtomicInteger[] importedCounter = {new AtomicInteger()}; - for (List listToProcess : splittedOrders) { - List calls = new ArrayList<>(); + for (List listToProcess : splittedOrders) { + List calls = new ArrayList<>(); - for (EquatableEntityInterface dtbOrdtToSave : listToProcess) { - //calls.add(() -> { + for (EquatableEntityInterface dtbOrdtToSave : listToProcess) { + //calls.add(() -> { - logger.debug("Importati {} di {}", importedCounter[0].incrementAndGet(), allData.size()); - try { - entityProcessor.processEntity(dtbOrdtToSave, multiDBTransactionManager); + logger.debug("Importati {} di {}", importedCounter[0].incrementAndGet(), allData.size()); + try { + entityProcessor.processEntity(dtbOrdtToSave, internalMultiDb); - singleUpdateImported(exchangeDb.getPrimaryConnection(), (DtbOrdt) dtbOrdtToSave, useTempTable); - multiDBTransactionManager.commitAll(); - exchangeDb.commitAll(); - } catch (Exception ex) { - if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; - - logger.error("Errore durante l'importazione dell'ordine", ex); - multiDBTransactionManager.rollbackAll(); - //throw ex; - } - //}); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (DtbOrdt) dtbOrdtToSave, useTempTable); + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); + } catch (Exception ex) { + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; + logger.error("Errore durante l'importazione dell'ordine", ex); + internalMultiDb.rollbackAll(); + //throw ex; } + //}); - - //UtilityThread.executeParallel(calls); } - if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; - } finally { - if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.OrdiniLavorazione); + + //UtilityThread.executeParallel(calls); } + + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.OrdiniLavorazione); } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangePartiteMagazzinoImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangePartiteMagazzinoImportService.java index ac80ccda9e..c1e77dd2e5 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangePartiteMagazzinoImportService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangePartiteMagazzinoImportService.java @@ -12,7 +12,6 @@ import it.integry.ems_model.utility.UtilityLocalDate; 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.stereotype.Service; import java.sql.Connection; @@ -24,7 +23,6 @@ import java.util.concurrent.atomic.AtomicInteger; @SuppressWarnings("rawtypes") @Service -@Scope("request") public class ExchangePartiteMagazzinoImportService { //TODO: To be remove, only for fast development @@ -35,9 +33,6 @@ public class ExchangePartiteMagazzinoImportService { @Autowired private EntityProcessor entityProcessor; - @Autowired - private MultiDBTransactionManager multiDBTransactionManager; - @Autowired private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; @@ -46,22 +41,21 @@ public class ExchangePartiteMagazzinoImportService { private final Logger logger = LogManager.getLogger(); - public void importPartiteMagazzinoLavorazione() throws Exception { + public void importPartiteMagazzinoLavorazione(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb) throws Exception { boolean useTempTable = true; - try (MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(ROSSOGARGANO_EXCHANGE_PROFILEDB)) { try { - exchangeImportSchemaManagerService.syncSchema(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.PartiteMagazzinoLavorazione, useTempTable); + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.PartiteMagazzinoLavorazione, useTempTable); final List exchangeImportedData = retrievePartite( - exchangeDb.getPrimaryConnection(), + exchangeMultiDb.getPrimaryConnection(), UtilityLocalDate.getNow().minusMonths(3), UtilityLocalDate.getNow(), true, false); final List exchangeUpdatedData = retrievePartite( - exchangeDb.getPrimaryConnection(), + exchangeMultiDb.getPrimaryConnection(), UtilityLocalDate.getNow().minusMonths(3), UtilityLocalDate.getNow(), false, useTempTable); @@ -83,13 +77,13 @@ public class ExchangePartiteMagazzinoImportService { // calls.add(() -> { logger.debug("Importate {} partite di magazzino di {}", importedCounter.incrementAndGet(), allData.size()); try { - entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, multiDBTransactionManager); + entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, internalMultiDb); - singleUpdateImported(exchangeDb.getPrimaryConnection(), (MtbPartitaMag) dataToSave, useTempTable); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (MtbPartitaMag) dataToSave, useTempTable); //multiDBTransactionManager.commitAll(); - multiDBTransactionManager.commitAll(); - exchangeDb.commitAll(); + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); } catch (Exception ex) { if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; @@ -107,9 +101,8 @@ public class ExchangePartiteMagazzinoImportService { if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; } finally { if (useTempTable) - exchangeImportSchemaManagerService.deleteTempTables(exchangeDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.PartiteMagazzinoLavorazione); + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.PartiteMagazzinoLavorazione); } - } } 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 new file mode 100644 index 0000000000..96d446cfb9 --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java @@ -0,0 +1,76 @@ +package it.integry.ems.system.exchange.service; + +import it.integry.annotations.PostContextAutowired; +import it.integry.annotations.PostContextConstruct; +import it.integry.ems.sync.MultiDBTransaction.AdvancedDataSource; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems_model.entity.StbExchangeConfig; +import it.integry.ems_model.entity.StbExchangeConfigDetail; +import it.integry.ems_model.utility.UtilityDB; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.scheduling.TaskScheduler; +import org.springframework.scheduling.support.CronTrigger; +import org.springframework.stereotype.Component; + +import java.util.HashMap; +import java.util.List; +import java.util.concurrent.ScheduledFuture; + +@Component +public class ExchangeSystemManagerService { + + + @PostContextAutowired + private MultiDBTransactionManager multiDBTransactionManager; + + @Autowired + private TaskScheduler taskScheduler; + + private final HashMap> scheduledOperations = new HashMap<>(); + + @PostContextConstruct(priority = 20) + public void init() throws Exception { + + for (AdvancedDataSource db : multiDBTransactionManager.getActiveConnections()) { + + String query = "SELECT cast(Count(*) as bit) existTable FROM sys.objects WHERE object_id = OBJECT_ID(N'" + StbExchangeConfig.ENTITY + "') AND type in (N'U')"; + boolean existTable = UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(db.getConnection(), query); + + if (!existTable) continue; + + List stbExchangeConfigsToRetrieve = UtilityDB.executeSimpleQueryDTO(db.getConnection(), + "SELECT * FROM " + StbExchangeConfig.ENTITY, StbExchangeConfig.class); + if (stbExchangeConfigsToRetrieve == null) continue; + + for (StbExchangeConfig stbExchangeConfig : stbExchangeConfigsToRetrieve) { + registerSchedulation(stbExchangeConfig); + } + } + + + } + + private void registerSchedulation(StbExchangeConfig stbExchangeConfig) { + if (scheduledOperations.containsKey(stbExchangeConfig.getId())) { + scheduledOperations.get(stbExchangeConfig.getId()).cancel(false); + scheduledOperations.remove(stbExchangeConfig.getId()); + } + + CronTrigger cronTrigger = new CronTrigger(stbExchangeConfig.getSchedulationCron()); + + ScheduledFuture future = + taskScheduler.schedule(() -> executeExchange(stbExchangeConfig), cronTrigger); + + scheduledOperations.put(stbExchangeConfig.getId(), future); + } + + private void executeExchange(StbExchangeConfig stbExchangeConfig) { + + + for (StbExchangeConfigDetail stbExchangeConfigDetail : stbExchangeConfig.getStbExchangeConfigDetail()) { + + } + + } + +}