From 4cc3732e30edd2d97330cfab562c32c2e457add0 Mon Sep 17 00:00:00 2001 From: GiuseppeS Date: Tue, 30 Jan 2024 17:55:43 +0100 Subject: [PATCH] Creato prima sistema di retrieve dello storico delle transazioni --- .../integry/ems/async/dto/TransactionDTO.java | 44 +---- .../ems/async/service/AsyncServiceNew.java | 6 +- .../integry/ems/dto/EntityHierarchyDTO.java | 12 ++ .../model/Migration_20240124171059.java | 16 +- .../it/integry/ems/service/EmsServices.java | 2 +- .../integry/ems/sync/AsyncHistoryManager.java | 177 ++++++++++++++++++ .../MultiDBTransactionManager.java | 8 +- .../RemoteSyncronizationController.java | 26 +++ .../RemoteSyncronizationSetupController.java | 27 ++- .../ems/sync/dto/ExportHistoryGroupDTO.java | 28 +++ .../ems/sync/dto/ExportHistoryItemDTO.java | 64 +++++++ .../InsertPublicationGroupRequestDTO.java | 2 +- .../InsertPublicationGroupResponseDTO.java | 2 +- .../dto/InsertPublicationItemResponseDTO.java | 15 ++ .../integry/ems/sync/dto}/PublicationDTO.java | 25 ++- .../ems/sync/dto}/PublicationGroupDTO.java | 2 +- .../service/RemoteSyncronizationService.java | 50 +++++ .../RemoteSyncronizationSetupService.java | 64 ++++--- .../it/integry/ems/utility/UtilityEntity.java | 7 + .../it/integry/ems_model/base/EntityBase.java | 16 +- .../ems_model/base/EntityPropertyHolder.java | 57 ++++-- .../entity/StbPublicationsDetail.java | 36 ++-- .../ems_model/entity/StbTransactionLogDb.java | 114 +++++++++++ .../BarcodeEan128/UtilityBarcodeEan128.java | 14 +- .../src/test/java/EntityTestDefaultVal.java | 2 +- .../service/MesProductionServiceV2.java | 13 +- .../utility/controller/UtilityController.java | 20 +- 27 files changed, 683 insertions(+), 166 deletions(-) create mode 100644 ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java create mode 100644 ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationController.java rename {ems-engine/src/main/java/it/integry/ems/system => ems-core/src/main/java/it/integry/ems/sync}/controller/RemoteSyncronizationSetupController.java (55%) create mode 100644 ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryGroupDTO.java create mode 100644 ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryItemDTO.java rename {ems-engine/src/main/java/it/integry/ems/system/dto/syncronization => ems-core/src/main/java/it/integry/ems/sync/dto}/InsertPublicationGroupRequestDTO.java (85%) rename {ems-engine/src/main/java/it/integry/ems/system/dto/syncronization => ems-core/src/main/java/it/integry/ems/sync/dto}/InsertPublicationGroupResponseDTO.java (82%) create mode 100644 ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationItemResponseDTO.java rename {ems-engine/src/main/java/it/integry/ems/system/dto/syncronization => ems-core/src/main/java/it/integry/ems/sync/dto}/PublicationDTO.java (58%) rename {ems-engine/src/main/java/it/integry/ems/system/dto/syncronization => ems-core/src/main/java/it/integry/ems/sync/dto}/PublicationGroupDTO.java (94%) create mode 100644 ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationService.java rename {ems-engine/src/main/java/it/integry/ems/system => ems-core/src/main/java/it/integry/ems/sync}/service/RemoteSyncronizationSetupService.java (71%) create mode 100644 ems-core/src/main/java/it/integry/ems_model/entity/StbTransactionLogDb.java diff --git a/ems-core/src/main/java/it/integry/ems/async/dto/TransactionDTO.java b/ems-core/src/main/java/it/integry/ems/async/dto/TransactionDTO.java index 5e9f4b8e65..c9400ad7e4 100644 --- a/ems-core/src/main/java/it/integry/ems/async/dto/TransactionDTO.java +++ b/ems-core/src/main/java/it/integry/ems/async/dto/TransactionDTO.java @@ -4,16 +4,13 @@ import java.util.Date; public class TransactionDTO { - public String publicationId; - public int transactionId; - public Date transactionDate; - public String username; - public String entityName; - public String errorMsg; - public String esito; - public Date execDate; - public String transactionJson; - public int transactionGroupId; + private String publicationId; + private int transactionId; + private Date transactionDate; + private String username; + private String entityName; + private String transactionJson; + private int transactionGroupId; public String getPublicationId() { return publicationId; @@ -60,33 +57,6 @@ public class TransactionDTO { return this; } - public String getErrorMsg() { - return errorMsg; - } - - public TransactionDTO setErrorMsg(String errorMsg) { - this.errorMsg = errorMsg; - return this; - } - - public String getEsito() { - return esito; - } - - public TransactionDTO setEsito(String esito) { - this.esito = esito; - return this; - } - - public Date getExecDate() { - return execDate; - } - - public TransactionDTO setExecDate(Date execDate) { - this.execDate = execDate; - return this; - } - public String getTransactionJson() { return transactionJson; } diff --git a/ems-core/src/main/java/it/integry/ems/async/service/AsyncServiceNew.java b/ems-core/src/main/java/it/integry/ems/async/service/AsyncServiceNew.java index 76ccf39489..6cfda76c45 100644 --- a/ems-core/src/main/java/it/integry/ems/async/service/AsyncServiceNew.java +++ b/ems-core/src/main/java/it/integry/ems/async/service/AsyncServiceNew.java @@ -129,8 +129,8 @@ public class AsyncServiceNew { final List transactionsIDGroups = new ArrayList<>(); for (TransactionDTO dto : transactionDTOS) { - if (!transactionsIDGroups.contains(dto.transactionGroupId)) - transactionsIDGroups.add(dto.transactionGroupId); + if (!transactionsIDGroups.contains(dto.getTransactionGroupId())) + transactionsIDGroups.add(dto.getTransactionGroupId()); } //Per ogni transaction group trovato mi prendo tutte le transactions @@ -143,7 +143,7 @@ public class AsyncServiceNew { List entitiesToImport = new ArrayList(); for (TransactionDTO transaction : transactionsToImport) { - EntityBase entity = jsonObjectMapper.readValue(transaction.transactionJson, EntityBase.class); + EntityBase entity = jsonObjectMapper.readValue(transaction.getTransactionJson(), EntityBase.class); entitiesToImport.add(entity); } diff --git a/ems-core/src/main/java/it/integry/ems/dto/EntityHierarchyDTO.java b/ems-core/src/main/java/it/integry/ems/dto/EntityHierarchyDTO.java index 580dd72e35..9d874c22b2 100644 --- a/ems-core/src/main/java/it/integry/ems/dto/EntityHierarchyDTO.java +++ b/ems-core/src/main/java/it/integry/ems/dto/EntityHierarchyDTO.java @@ -1,13 +1,25 @@ package it.integry.ems.dto; +import it.integry.ems_model.base.EntityBase; + import java.util.List; public class EntityHierarchyDTO { + private Class clazz; private String entityName; private String tableName; private List children; + public Class getClazz() { + return clazz; + } + + public EntityHierarchyDTO setClazz(Class clazz) { + this.clazz = clazz; + return this; + } + public String getEntityName() { return entityName; } diff --git a/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240124171059.java b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240124171059.java index 2d07142369..e50c60b955 100644 --- a/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240124171059.java +++ b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240124171059.java @@ -39,18 +39,25 @@ public class Migration_20240124171059 extends BaseMigration implements Migration for (HashMap oldStbPublicationDetail : oldStbPublicationsDetails) { + String active = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "syncronize"); String oldId = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "publication_id"); String entityName = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "entity_name"); String whereCondSql = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "where_cond_sql"); String recalcColumns = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "recalc_columns"); - String syncronize = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "syncronize"); String whereCond = UtilityHashMap.getValueIfExists(oldStbPublicationDetail, "where_cond"); Long newParentId = getNewGeneratedIdFromOldKey(oldId, oldStbPublications); String insertSql = Query.format("INSERT INTO stb_publications_detail " + - "(stb_publication_id, entity_name, where_cond_sql, recalc_columns, syncronize, where_cond) " + - "VALUES (%s, %s, %s, %s, %s, %s)", newParentId, entityName, whereCondSql, recalcColumns, syncronize.equalsIgnoreCase("S") || syncronize.equalsIgnoreCase("R"), whereCond); + "(stb_publication_id, entity_name, where_cond_sql, recalc_columns, syncronize, where_cond, ready_to_transmit) " + + "VALUES (%s, %s, %s, %s, %s, %s, %s)", + newParentId, + entityName, + whereCondSql, + recalcColumns, + active.equalsIgnoreCase("S") || active.equalsIgnoreCase("R"), + whereCond, + true); long generatedId = executeInsertStatement(advancedDataSource.getConnection(), insertSql); oldStbPublicationDetail.putIfAbsent("id", generatedId); } @@ -91,9 +98,10 @@ public class Migration_20240124171059 extends BaseMigration implements Migration " CONSTRAINT stb_publications_detail_stb_publications_id_fk\n" + " REFERENCES dbo.stb_publications (id),\n" + " entity_name VARCHAR(40) NOT NULL,\n" + + " active BIT DEFAULT 1 NOT NULL,\n" + + " ready_to_transmit BIT DEFAULT 0 NOT NULL,\n" + " where_cond_sql VARCHAR(MAX),\n" + " recalc_columns VARCHAR(MAX),\n" + - " syncronize BIT DEFAULT 1 NOT NULL,\n" + " where_cond VARCHAR(MAX)" + ")"; executeStatement(connection, createSql); diff --git a/ems-core/src/main/java/it/integry/ems/service/EmsServices.java b/ems-core/src/main/java/it/integry/ems/service/EmsServices.java index 49d2d125a8..83236286fe 100644 --- a/ems-core/src/main/java/it/integry/ems/service/EmsServices.java +++ b/ems-core/src/main/java/it/integry/ems/service/EmsServices.java @@ -993,7 +993,7 @@ public class EmsServices { } public List getEntityMapping() { - return entityPropertyHolder.getEntityMapping(); + return entityPropertyHolder.getEntityHierarchyMap(); } public List getEntityDetails(String entityName) { 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 new file mode 100644 index 0000000000..847a171d80 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/AsyncHistoryManager.java @@ -0,0 +1,177 @@ +package it.integry.ems.sync; + +import it.integry.annotations.PostContextConstruct; +import it.integry.ems.datasource.DataSource; +import it.integry.ems.json.JSONObjectMapper; +import it.integry.ems.looper.service.LooperService; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems.sync.dto.ExportHistoryItemDTO; +import it.integry.ems.sync.dto.PublicationDTO; +import it.integry.ems_model.base.EntityBase; +import it.integry.ems_model.base.EntityPropertyHolder; +import it.integry.ems_model.entity.StbTransactionLogDb; +import it.integry.ems_model.types.OperationType; +import it.integry.ems_model.utility.UtilityDB; +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.stereotype.Component; + +import java.sql.Connection; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +@Component +public class AsyncHistoryManager { + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private LooperService looperService; + + @Autowired + private EntityPropertyHolder entityPropertyHolder; + + @Autowired + private JSONObjectMapper jsonObjectMapper; + + //Implement check list like distribuzione + private final HashMap> currentlyInExecution = new HashMap<>(); + + + @PostContextConstruct + public void init() { + this.looperService.add(this::consumeRetrieveQueue, 10 * 1000, "async-history-read"); + this.looperService.add(this::consumeProcessedQueue, 10 * 1000, "async-history-save"); + } + + public void addToExportQueue(DataSource dataSource, long groupId, PublicationDTO publication) throws Exception { + + tryAddInExecutionList(groupId, new ExportHistoryItemDTO() + .setPublication(publication) + .setDataSource(dataSource)); + } + + private void tryAddInExecutionList(long groupId, ExportHistoryItemDTO exportHistoryItemDTO) throws Exception { + currentlyInExecution.putIfAbsent(groupId, new ArrayList<>()); + + List list = currentlyInExecution.get(groupId); + final boolean alreadyRegistered = list.stream() + .anyMatch(x -> x.getPublication().getId() == exportHistoryItemDTO.getPublication().getId()); + + if (alreadyRegistered) { + throw new Exception("Il sistema sta già elaborando questa publication"); + } + + exportHistoryItemDTO.setTotalItemCount(countExistingItems(exportHistoryItemDTO)); + + list.add(exportHistoryItemDTO); + } + + private void consumeRetrieveQueue() { + final List currentlyInExecutionKeys = new ArrayList<>(currentlyInExecution.keySet()); + + for (long currentGroupId : currentlyInExecutionKeys) { + List entitiesToExport = currentlyInExecution.get(currentGroupId); + + for (ExportHistoryItemDTO entityToExport : entitiesToExport) { + try { + internalExportEntity(entityToExport); + } catch (Exception ex) { + logger.error(ex.getMessage(), ex); + } + } + } + } + + + private void internalExportEntity(ExportHistoryItemDTO entityHistoryToExport) throws Exception { + final Class entityClass = entityPropertyHolder.getEntityClassFromTableName(entityHistoryToExport.getPublication().getEntityName()); + + try (MultiDBTransactionManager newConnection = new MultiDBTransactionManager(entityHistoryToExport.getDataSource().getProfile())) { + retrieveEntitiesByChunk(newConnection.getPrimaryConnection(), entityHistoryToExport, entityClass); + } + } + + private long countExistingItems(ExportHistoryItemDTO entityHistoryToExport) throws Exception { + final Class entityClass = entityPropertyHolder.getEntityClassFromTableName(entityHistoryToExport.getPublication().getEntityName()); + + try (MultiDBTransactionManager newConnection = new MultiDBTransactionManager(entityHistoryToExport.getDataSource().getProfile())) { + String sql = "SELECT CONVERT(BIGINT, COUNT(*)) FROM " + entityClass.newInstance().getTableName(); + return UtilityDB.executeSimpleQueryOnlyFirstRowFirstColumn(newConnection.getPrimaryConnection(), sql); + } + } + + private void retrieveEntitiesByChunk(Connection connection, ExportHistoryItemDTO exportHistoryItem, Class entityClass) throws Exception { + + long totalItemCount = exportHistoryItem.getTotalItemCount(); + int chunkSize = 10000; + + for (int chunkIndex = 0; chunkIndex < (totalItemCount / chunkSize) + 1; chunkIndex++) { + + String innerSql = "SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS row_number " + + "FROM " + exportHistoryItem.getPublication().getEntityName(); + + innerSql = UtilityDB.addwhereCond(innerSql, exportHistoryItem.getPublication().getWhereCond(), true); + + String sql = "WITH TempResult AS (\n" + + innerSql + ")\n" + + "SELECT TempResult.*\n" + + "FROM TempResult\n" + + "ORDER BY row_number\n" + + "OFFSET (" + chunkIndex + ") * " + chunkSize + " ROWS FETCH NEXT " + chunkSize + " ROWS ONLY"; + + final List selectedChunk = UtilityDB.executeSimpleQueryDTO(connection, sql, entityClass); + + if (selectedChunk == null || selectedChunk.isEmpty()) continue; + + exportHistoryItem.setProcessedItemCount(exportHistoryItem.getProcessedItemCount() + selectedChunk.size()); + logger.debug("COUNT: " + exportHistoryItem.getProcessedItemCount()); + + selectedChunk.forEach(x -> exportHistoryItem.getToProcessQueue().add(x)); + } + } + + + private void consumeProcessedQueue() { + final List currentlyInExecutionKeys = new ArrayList<>(currentlyInExecution.keySet()); + + for (long currentGroupId : currentlyInExecutionKeys) { + List entitiesToExport = currentlyInExecution.get(currentGroupId); + + for (ExportHistoryItemDTO entityToExport : entitiesToExport) { + try { + internalProcessQueue(entityToExport); + } catch (Exception ex) { + logger.error(ex.getMessage(), ex); + } + } + } + } + + private void internalProcessQueue(ExportHistoryItemDTO entityToExport) throws Exception { + logger.debug("TBS COUNT: " + entityToExport.getToProcessQueue().size()); + + try (MultiDBTransactionManager multiDBTransactionManager = new MultiDBTransactionManager(entityToExport.getDataSource().getProfile())) { + + EntityBase entity; + while ((entity = entityToExport.getToProcessQueue().poll()) != null) { + + StbTransactionLogDb stbTransactionLogDb = new StbTransactionLogDb() + .setTransactionDate(UtilityLocalDate.getNowTime()) + .setTransactionJson(jsonObjectMapper.writeValueAsString(entity)) + .setTransactionGroupIdField(-1) + .setEntityNameList(entityToExport.getPublication().getEntityName()); + + stbTransactionLogDb + .setOperation(OperationType.INSERT); + + stbTransactionLogDb.manageWithParentConnection(multiDBTransactionManager.getPrimaryConnection()); + } + + } + } + +} 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 01cf3e5d2b..e1711fa86d 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 @@ -26,7 +26,7 @@ import java.util.List; @Service @Scope("request") -public class MultiDBTransactionManager { +public class MultiDBTransactionManager implements AutoCloseable{ private final static Logger logger = LogManager.getLogger(); @@ -234,6 +234,11 @@ public class MultiDBTransactionManager { } } + @Override + public void close() throws Exception { + closeAll(); + } + public void closeAll() throws Exception { for (AdvancedDataSource advancedDataSource : dbDatasources) { if (!advancedDataSource.isClosed()) { @@ -333,4 +338,5 @@ public class MultiDBTransactionManager { !uri.contains("getOpenedSteps") && !uri.contains("getCurrentPrintQueue"); } + } diff --git a/ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationController.java b/ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationController.java new file mode 100644 index 0000000000..06b96c8ca5 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationController.java @@ -0,0 +1,26 @@ +package it.integry.ems.sync.controller; + +import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.service.RemoteSyncronizationService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Scope; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@Scope("request") +@RequestMapping("system/remote-sync") +public class RemoteSyncronizationController { + + @Autowired + private RemoteSyncronizationService remoteSyncronizationService; + + @RequestMapping(value = "publications/{groupId}/start", method = RequestMethod.GET) + public ServiceRestResponse startPublication(@PathVariable long groupId) throws Exception { + remoteSyncronizationService.startPublication(groupId); + return ServiceRestResponse.createPositiveResponse(); + } + +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/controller/RemoteSyncronizationSetupController.java b/ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationSetupController.java similarity index 55% rename from ems-engine/src/main/java/it/integry/ems/system/controller/RemoteSyncronizationSetupController.java rename to ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationSetupController.java index 6bedf777f5..be21e12fca 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/controller/RemoteSyncronizationSetupController.java +++ b/ems-core/src/main/java/it/integry/ems/sync/controller/RemoteSyncronizationSetupController.java @@ -1,24 +1,19 @@ -package it.integry.ems.system.controller; +package it.integry.ems.sync.controller; import it.integry.ems.response.ServiceRestResponse; -import it.integry.ems.system.dto.syncronization.InsertPublicationGroupRequestDTO; -import it.integry.ems.system.service.RemoteSyncronizationSetupService; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; +import it.integry.ems.sync.dto.InsertPublicationGroupRequestDTO; +import it.integry.ems.sync.dto.InsertPublicationItemResponseDTO; +import it.integry.ems.sync.dto.PublicationDTO; +import it.integry.ems.sync.service.RemoteSyncronizationSetupService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Scope; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.bind.annotation.*; @RestController @Scope("request") @RequestMapping("system/remote-sync/setup") public class RemoteSyncronizationSetupController { - private final Logger logger = LogManager.getLogger(); - @Autowired private RemoteSyncronizationSetupService remoteSyncronizationSetupService; @@ -35,9 +30,13 @@ public class RemoteSyncronizationSetupController { } - @RequestMapping(value = "publications/insert", method = RequestMethod.POST) - public ServiceRestResponse insertPublications() throws Exception { - return ServiceRestResponse.createPositiveResponse(remoteSyncronizationSetupService.retrievePublications()); + @RequestMapping(value = "publications/{groupId}/insert", method = RequestMethod.POST) + public ServiceRestResponse insertPublications(@PathVariable long groupId, @RequestBody PublicationDTO publicationToInsert) throws Exception { + InsertPublicationItemResponseDTO response = new InsertPublicationItemResponseDTO() + .setId(remoteSyncronizationSetupService.addPublicationItem(groupId, publicationToInsert)); + + + return ServiceRestResponse.createPositiveResponse(response); } diff --git a/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryGroupDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryGroupDTO.java new file mode 100644 index 0000000000..17f50742f5 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryGroupDTO.java @@ -0,0 +1,28 @@ +package it.integry.ems.sync.dto; + +import java.util.List; + +public class ExportHistoryGroupDTO { + + private long groupId; + private List items; + + + public long getGroupId() { + return groupId; + } + + public ExportHistoryGroupDTO setGroupId(long groupId) { + this.groupId = groupId; + return this; + } + + public List getItems() { + return items; + } + + public ExportHistoryGroupDTO setItems(List items) { + this.items = items; + return this; + } +} diff --git a/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryItemDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryItemDTO.java new file mode 100644 index 0000000000..c2f9ca8e36 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/ExportHistoryItemDTO.java @@ -0,0 +1,64 @@ +package it.integry.ems.sync.dto; + +import it.integry.ems.datasource.DataSource; +import it.integry.ems_model.base.EntityBase; + +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; + +public class ExportHistoryItemDTO { + + + private DataSource dataSource; + private PublicationDTO publication; + private long totalItemCount; + private long processedItemCount; + + private Queue toProcessQueue = new ConcurrentLinkedQueue(); + + + public DataSource getDataSource() { + return dataSource; + } + + public ExportHistoryItemDTO setDataSource(DataSource dataSource) { + this.dataSource = dataSource; + return this; + } + + public PublicationDTO getPublication() { + return publication; + } + + public ExportHistoryItemDTO setPublication(PublicationDTO publication) { + this.publication = publication; + return this; + } + + public long getTotalItemCount() { + return totalItemCount; + } + + public ExportHistoryItemDTO setTotalItemCount(long totalItemCount) { + this.totalItemCount = totalItemCount; + return this; + } + + public long getProcessedItemCount() { + return processedItemCount; + } + + public ExportHistoryItemDTO setProcessedItemCount(long processedItemCount) { + this.processedItemCount = processedItemCount; + return this; + } + + public Queue getToProcessQueue() { + return toProcessQueue; + } + + public ExportHistoryItemDTO setToProcessQueue(Queue toProcessQueue) { + this.toProcessQueue = toProcessQueue; + return this; + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupRequestDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupRequestDTO.java similarity index 85% rename from ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupRequestDTO.java rename to ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupRequestDTO.java index 5be6d71e8b..5dbe583b57 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupRequestDTO.java +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupRequestDTO.java @@ -1,4 +1,4 @@ -package it.integry.ems.system.dto.syncronization; +package it.integry.ems.sync.dto; public class InsertPublicationGroupRequestDTO { diff --git a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupResponseDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupResponseDTO.java similarity index 82% rename from ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupResponseDTO.java rename to ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupResponseDTO.java index 785ba03e88..ad31662c08 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/InsertPublicationGroupResponseDTO.java +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationGroupResponseDTO.java @@ -1,4 +1,4 @@ -package it.integry.ems.system.dto.syncronization; +package it.integry.ems.sync.dto; public class InsertPublicationGroupResponseDTO { diff --git a/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationItemResponseDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationItemResponseDTO.java new file mode 100644 index 0000000000..29cb0d1f1c --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/InsertPublicationItemResponseDTO.java @@ -0,0 +1,15 @@ +package it.integry.ems.sync.dto; + +public class InsertPublicationItemResponseDTO { + + private long id; + + public long getId() { + return id; + } + + public InsertPublicationItemResponseDTO setId(long id) { + this.id = id; + return this; + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/PublicationDTO.java similarity index 58% rename from ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationDTO.java rename to ems-core/src/main/java/it/integry/ems/sync/dto/PublicationDTO.java index 5baab7bff9..1d837c8880 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationDTO.java +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/PublicationDTO.java @@ -1,4 +1,6 @@ -package it.integry.ems.system.dto.syncronization; +package it.integry.ems.sync.dto; + +import it.integry.ems_model.entity.StbPublicationsDetail; public class PublicationDTO { @@ -6,9 +8,20 @@ public class PublicationDTO { private String entityName; private String whereCondSql; private String recalcColumns; - private boolean syncronize; + private boolean active; private String whereCond; + + public static PublicationDTO fromStbPublicationDetail(StbPublicationsDetail stbPublicationsDetail) { + return new PublicationDTO() + .setActive(stbPublicationsDetail.isActive()) + .setId(stbPublicationsDetail.getId()) + .setRecalcColumns(stbPublicationsDetail.getRecalcColumnsField()) + .setEntityName(stbPublicationsDetail.getEntityName()) + .setWhereCond(stbPublicationsDetail.getWhereCondField()) + .setWhereCondSql(stbPublicationsDetail.getWhereCondSql()); + } + public long getId() { return id; } @@ -45,12 +58,12 @@ public class PublicationDTO { return this; } - public boolean isSyncronize() { - return syncronize; + public boolean isActive() { + return active; } - public PublicationDTO setSyncronize(boolean syncronize) { - this.syncronize = syncronize; + public PublicationDTO setActive(boolean active) { + this.active = active; return this; } diff --git a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationGroupDTO.java b/ems-core/src/main/java/it/integry/ems/sync/dto/PublicationGroupDTO.java similarity index 94% rename from ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationGroupDTO.java rename to ems-core/src/main/java/it/integry/ems/sync/dto/PublicationGroupDTO.java index c21560f847..833c26cd33 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/dto/syncronization/PublicationGroupDTO.java +++ b/ems-core/src/main/java/it/integry/ems/sync/dto/PublicationGroupDTO.java @@ -1,4 +1,4 @@ -package it.integry.ems.system.dto.syncronization; +package it.integry.ems.sync.dto; import java.util.ArrayList; import java.util.List; diff --git a/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationService.java b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationService.java new file mode 100644 index 0000000000..0968fc8b75 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationService.java @@ -0,0 +1,50 @@ +package it.integry.ems.sync.service; + +import it.integry.ems.sync.AsyncHistoryManager; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems.sync.dto.PublicationDTO; +import it.integry.ems.utility.UtilityEntity; +import it.integry.ems_model.base.EntityBase; +import it.integry.ems_model.base.EntityPropertyHolder; +import it.integry.ems_model.entity.StbPublicationsDetail; +import it.integry.ems_model.utility.Query; +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.List; + +@Service +@Scope(value = "request") +public class RemoteSyncronizationService { + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private MultiDBTransactionManager multiDBTransactionManager; + + @Autowired + private AsyncHistoryManager asyncHistoryManager; + + @Autowired + private EntityPropertyHolder entityPropertyHolder; + + public void startPublication(long groupId) throws Exception { + + StbPublicationsDetail tmpStbPublicationsDetail = new StbPublicationsDetail(); + String whereCond = Query.format("stb_publication_id = %s", groupId); + + final List select = tmpStbPublicationsDetail.select(multiDBTransactionManager.getPrimaryConnection(), whereCond); + final List stbPublicationsDetails = UtilityEntity.toCustomEntity(select); + + for (StbPublicationsDetail stbPublicationsDetail : stbPublicationsDetails) { + asyncHistoryManager.addToExportQueue(multiDBTransactionManager.getPrimaryDatasource(), + groupId, + PublicationDTO.fromStbPublicationDetail(stbPublicationsDetail)); + } + + + } +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/service/RemoteSyncronizationSetupService.java b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationSetupService.java similarity index 71% rename from ems-engine/src/main/java/it/integry/ems/system/service/RemoteSyncronizationSetupService.java rename to ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationSetupService.java index f2351ba3b6..203e73a2d8 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/service/RemoteSyncronizationSetupService.java +++ b/ems-core/src/main/java/it/integry/ems/sync/service/RemoteSyncronizationSetupService.java @@ -1,9 +1,9 @@ -package it.integry.ems.system.service; +package it.integry.ems.sync.service; import it.integry.ems.service.EntityProcessor; import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; -import it.integry.ems.system.dto.syncronization.PublicationDTO; -import it.integry.ems.system.dto.syncronization.PublicationGroupDTO; +import it.integry.ems.sync.dto.PublicationDTO; +import it.integry.ems.sync.dto.PublicationGroupDTO; import it.integry.ems.utility.UtilityEntity; import it.integry.ems_model.base.EntityBase; import it.integry.ems_model.base.EntityPropertyHolder; @@ -55,6 +55,8 @@ public class RemoteSyncronizationSetupService { tmpStbPublicationsDetail.setOperation(OperationType.SELECT); tmpStbPublicationsDetail.setOnlyPkMaster(false); List selectedStbPublicationsDetail = entityProcessor.processEntity(tmpStbPublicationsDetail, multiDBTransactionManager); + if(selectedStbPublicationsDetail == null) selectedStbPublicationsDetail = new ArrayList<>(); + List stbPublicationsDetails = UtilityEntity.toCustomEntity(selectedStbPublicationsDetail); @@ -70,13 +72,7 @@ public class RemoteSyncronizationSetupService { final List publications = stbPublicationsDetails.stream() .filter(x -> x.getStbPublicationId() == stbPublication.getId()) - .map(x -> new PublicationDTO() - .setId(x.getId()) - .setSyncronize(x.isSyncronize()) - .setEntityName(x.getEntityName()) - .setWhereCond(x.getWhereCondField()) - .setWhereCondSql(x.getWhereCondSql()) - .setRecalcColumns(x.getRecalcColumnsField())) + .map(PublicationDTO::fromStbPublicationDetail) .collect(toList()); publicationGroupDTO.setPublications(publications); } @@ -95,22 +91,48 @@ public class RemoteSyncronizationSetupService { return stbPublications.getId(); } - public void addPublications(long publicationId, @NotNull List publications) throws Exception { + + public long addPublicationItem(long groupId, @NotNull PublicationDTO publicationToInsert) throws Exception { + final StbPublicationsDetail stbPublicationsDetail = new StbPublicationsDetail() + .setStbPublicationId(groupId) + .setEntityName(publicationToInsert.getEntityName()) + .setWhereCondSql(publicationToInsert.getWhereCondSql()) + .setRecalcColumns(publicationToInsert.getRecalcColumns()) + .setActive(publicationToInsert.isActive()) + .setWhereCondField(publicationToInsert.getWhereCond()); + stbPublicationsDetail.setOperation(OperationType.INSERT); + + StbPublications stbPublications = new StbPublications() + .setId(groupId); + stbPublications.setOperation(OperationType.NO_OP); + stbPublications.getStbPublicationsDetails().add(stbPublicationsDetail); + + entityProcessor.processEntity(stbPublications, multiDBTransactionManager); + + return stbPublications.getStbPublicationsDetails().get(0).getId(); + } + + public void addPublications(long groupId, @NotNull List publications) throws Exception { final List stbPublicationsToInsert = publications.stream() - .map(x -> new StbPublicationsDetail() - .setStbPublicationId(publicationId) - .setEntityName(x.getEntityName()) - .setWhereCondSql(x.getWhereCondSql()) - .setRecalcColumns(x.getRecalcColumns()) - .setSyncronize(x.isSyncronize()) - .setWhereCondField(x.getWhereCond())) + .map(x -> { + StbPublicationsDetail stbPublicationsDetail = new StbPublicationsDetail() + .setStbPublicationId(groupId) + .setEntityName(x.getEntityName()) + .setWhereCondSql(x.getWhereCondSql()) + .setRecalcColumns(x.getRecalcColumns()) + .setActive(x.isActive()) + .setWhereCondField(x.getWhereCond()); + stbPublicationsDetail.setOperation(OperationType.INSERT); + return stbPublicationsDetail; + }) .collect(Collectors.toList()); StbPublications stbPublications = new StbPublications() - .setId(publicationId); + .setId(groupId) + .setStbPublicationsDetails(stbPublicationsToInsert); stbPublications.setOperation(OperationType.NO_OP); - final List savedEntities = entityProcessor.processEntityList(stbPublicationsToInsert, multiDBTransactionManager, true); + final List savedEntities = entityProcessor.processEntity(stbPublications, multiDBTransactionManager); UtilityEntity.throwEntitiesException(savedEntities); } @@ -138,6 +160,4 @@ public class RemoteSyncronizationSetupService { final List savedEntities = entityProcessor.processEntityList(stbPublications.get(), multiDBTransactionManager, true); UtilityEntity.throwEntitiesException(savedEntities); } - - } diff --git a/ems-core/src/main/java/it/integry/ems/utility/UtilityEntity.java b/ems-core/src/main/java/it/integry/ems/utility/UtilityEntity.java index 42941e8c5a..99faf19488 100644 --- a/ems-core/src/main/java/it/integry/ems/utility/UtilityEntity.java +++ b/ems-core/src/main/java/it/integry/ems/utility/UtilityEntity.java @@ -108,4 +108,11 @@ public class UtilityEntity { return StringUtils.join(fieldsPK, "~"); } + + public String calculateWhereCond(T entity, boolean onlyPK) { + + + return null; + } + } diff --git a/ems-core/src/main/java/it/integry/ems_model/base/EntityBase.java b/ems-core/src/main/java/it/integry/ems_model/base/EntityBase.java index c56c6bd796..9ddcbfa4a2 100644 --- a/ems-core/src/main/java/it/integry/ems_model/base/EntityBase.java +++ b/ems-core/src/main/java/it/integry/ems_model/base/EntityBase.java @@ -1345,7 +1345,7 @@ public abstract class EntityBase implements Serializable, Cloneable, EntityInter Map mapLob = getFieldToQuery(fields, campi, valori); - if (campi.size() != 0) { + if (!campi.isEmpty()) { String sql = "INSERT INTO " + getTableName() + "(" + StringUtils.join(campi, ",") + ") " + "VALUES (" + StringUtils.join(valori, ",") + ")"; boolean containsIdentity; @@ -1589,16 +1589,6 @@ public abstract class EntityBase implements Serializable, Cloneable, EntityInter public void deleteAllEntities(Connection conn, EntityBase parent) throws Exception { String whereCondDel = parent.getWhereCondDelete(); deleteAllEntities(conn, whereCondDel); -// String sql = "DELETE " + getTableName() + " WHERE " + whereCondDel; -// -// if (logger.isTraceEnabled()) { -// logger.trace("QUERY: " + sql); -// } -// -// PreparedStatement pstm = conn.prepareStatement(sql); -// pstm.setQueryTimeout(queryTimeoutSeconds); -// pstm.executeUpdate(); -// pstm.close(); } private String getWhereCondDelete() throws Exception { @@ -2058,7 +2048,9 @@ public abstract class EntityBase implements Serializable, Cloneable, EntityInter public void resetIdentiy(Connection connection) throws Exception { Field[] fields = this.getClass().getDeclaredFields(); - Optional identityField = Stream.of(fields).filter(x -> x.isAnnotationPresent(Identity.class) && x.isAnnotationPresent(SqlField.class)).findFirst(); + Optional identityField = Stream.of(fields) + .filter(x -> x.isAnnotationPresent(Identity.class) && x.isAnnotationPresent(SqlField.class)) + .findFirst(); if (identityField.isPresent()) { String tableName = this.getTableName(); diff --git a/ems-core/src/main/java/it/integry/ems_model/base/EntityPropertyHolder.java b/ems-core/src/main/java/it/integry/ems_model/base/EntityPropertyHolder.java index 50c14299f1..3c892c15e6 100644 --- a/ems-core/src/main/java/it/integry/ems_model/base/EntityPropertyHolder.java +++ b/ems-core/src/main/java/it/integry/ems_model/base/EntityPropertyHolder.java @@ -36,6 +36,7 @@ public class EntityPropertyHolder { private final Logger logger = LogManager.getLogger(); + private List entityHierarchyMap; private final HashMap> entityNameMap = new HashMap<>(); private final HashMap classMap = new HashMap<>(); @@ -55,8 +56,45 @@ public class EntityPropertyHolder { return entityNameMap.getOrDefault(entityName, null); } + public Class getEntityClassFromTableName(String tableName) { + List tempList = new ArrayList<>(entityHierarchyMap); + tempList.addAll(tempList.stream().flatMap(x -> x.getChildren().stream()).collect(Collectors.toList())); + + return tempList.stream() + .filter(x -> x.getTableName().equalsIgnoreCase(tableName)) + .map(EntityHierarchyDTO::getClazz) + .findFirst().orElse(null); + } + + public List getEntityHierarchyMap() { + return entityHierarchyMap; + } + @PostConstruct - public void scanEntityFields() { + public void init() { + scanEntityFields(); + entityHierarchyMap = scanEntityMapping(); + } + + public List scanEntityMapping() { + Reflections reflections = new Reflections("it.integry.ems_model.entity"); + List mapping = new ArrayList<>(); + Set> classes = reflections.getSubTypesOf(EntityBase.class); + for (Class entity : classes) { + if (entity.isAnnotationPresent(Master.class)) { + EntityHierarchyDTO dto = new EntityHierarchyDTO(); + dto.setClazz(entity); + dto.setEntityName(entity.getSimpleName()); + dto.setTableName(entity.getAnnotation(Table.class).value()); + dto.setChildren(getEntityChildren(entity)); + mapping.add(dto); + } + } + return mapping; + } + + + private void scanEntityFields() { Reflections reflections = new Reflections("it.integry.ems_model.entity"); List> clssList = new ArrayList<>(Stream.of(reflections.getSubTypesOf(EntityBase.class)) @@ -471,22 +509,6 @@ public class EntityPropertyHolder { return null; } - public List getEntityMapping() { - Reflections reflections = new Reflections("it.integry.ems_model.entity"); - List mapping = new ArrayList<>(); - Set> classes = reflections.getSubTypesOf(EntityBase.class); - for (Class entity : classes) { - if (entity.isAnnotationPresent(Master.class)) { - EntityHierarchyDTO dto = new EntityHierarchyDTO(); - dto.setEntityName(entity.getSimpleName()); - dto.setTableName(entity.getAnnotation(Table.class).value()); - dto.setChildren(getEntityChildren(entity)); - mapping.add(dto); - } - } - return mapping; - } - public List getEntityChildren(Class entity) { List children = new ArrayList<>(); Field[] fields = entity.getDeclaredFields(); @@ -510,6 +532,7 @@ public class EntityPropertyHolder { continue; } EntityHierarchyDTO dto = new EntityHierarchyDTO(); + dto.setClazz(childEntity); dto.setEntityName(childEntity.getSimpleName()); dto.setTableName(childEntity.getAnnotation(Table.class).value()); dto.setChildren(getEntityChildren(childEntity)); diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/StbPublicationsDetail.java b/ems-core/src/main/java/it/integry/ems_model/entity/StbPublicationsDetail.java index 624d711939..4ed9fd0575 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/StbPublicationsDetail.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/StbPublicationsDetail.java @@ -26,12 +26,15 @@ public class StbPublicationsDetail extends EntityBase { @SqlField(value = "entity_name") private String entityName; + @SqlField(value = "active", defaultObjectValue="1", nullable = false) + private boolean active; + + @SqlField(value = "ready_to_transmit", defaultObjectValue="0", nullable = false) + private boolean readyToTransmit; + @SqlField(value = "recalc_columns") private String recalcColumnsField; - @SqlField(value = "syncronize", defaultObjectValue="1", nullable = false) - private boolean syncronize; - @SqlField(value = "where_cond_sql") private String whereCondSql; @@ -64,6 +67,24 @@ public class StbPublicationsDetail extends EntityBase { return this; } + public boolean isActive() { + return active; + } + + public StbPublicationsDetail setActive(boolean active) { + this.active = active; + return this; + } + + public boolean isReadyToTransmit() { + return readyToTransmit; + } + + public StbPublicationsDetail setReadyToTransmit(boolean readyToTransmit) { + this.readyToTransmit = readyToTransmit; + return this; + } + public String getRecalcColumnsField() { return recalcColumnsField; } @@ -73,15 +94,6 @@ public class StbPublicationsDetail extends EntityBase { return this; } - public boolean isSyncronize() { - return syncronize; - } - - public StbPublicationsDetail setSyncronize(boolean syncronize) { - this.syncronize = syncronize; - return this; - } - public String getWhereCondSql() { return whereCondSql; } diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/StbTransactionLogDb.java b/ems-core/src/main/java/it/integry/ems_model/entity/StbTransactionLogDb.java new file mode 100644 index 0000000000..b81d610b6e --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems_model/entity/StbTransactionLogDb.java @@ -0,0 +1,114 @@ +package it.integry.ems_model.entity; + +import com.fasterxml.jackson.annotation.JsonTypeName; +import it.integry.ems_model.annotation.*; +import it.integry.ems_model.base.EntityBase; +import org.kie.api.definition.type.PropertyReactive; + +import java.time.LocalDateTime; + +@Master +@PropertyReactive +@Table(StbTransactionLogDb.ENTITY) +@JsonTypeName(StbTransactionLogDb.ENTITY) +public class StbTransactionLogDb extends EntityBase { + + private static final long serialVersionUID = 1L; + + public static final String ENTITY = "stb_transaction_log_db"; + + @PK + @Identity + @SqlField(value = "id", nullable = false) + private long id; + + @SqlField(value = "transaction_date") + private LocalDateTime transactionDate; + + @SqlField(value = "user_name") + private String userName; + + @SqlField(value = "entity_name_list") + private String entityNameList; + +// @SqlField(value = "error_msg") +// private String errorMsg; + +// @SqlField(value = "esito") +// private String esito; + +// @SqlField(value = "exec_date") +// private LocalDateTime execDate; + + @SqlField(value = "transaction_json") + private String transactionJson; + + @SqlField(value = "transaction_group_id") + private int transactionGroupIdField; + + @SqlField(value = "transaction_query") + private String transactionQuery; + + public long getId() { + return id; + } + + public StbTransactionLogDb setId(long id) { + this.id = id; + return this; + } + + public LocalDateTime getTransactionDate() { + return transactionDate; + } + + public StbTransactionLogDb setTransactionDate(LocalDateTime transactionDate) { + this.transactionDate = transactionDate; + return this; + } + + public String getUserName() { + return userName; + } + + public StbTransactionLogDb setUserName(String userName) { + this.userName = userName; + return this; + } + + public String getEntityNameList() { + return entityNameList; + } + + public StbTransactionLogDb setEntityNameList(String entityNameList) { + this.entityNameList = entityNameList; + return this; + } + + public String getTransactionJson() { + return transactionJson; + } + + public StbTransactionLogDb setTransactionJson(String transactionJson) { + this.transactionJson = transactionJson; + return this; + } + + public int getTransactionGroupIdField() { + return transactionGroupIdField; + } + + public StbTransactionLogDb setTransactionGroupIdField(int transactionGroupIdField) { + this.transactionGroupIdField = transactionGroupIdField; + return this; + } + + public String getTransactionQuery() { + return transactionQuery; + } + + public StbTransactionLogDb setTransactionQuery(String transactionQuery) { + this.transactionQuery = transactionQuery; + return this; + } +} diff --git a/ems-core/src/main/java/it/integry/ems_model/utility/BarcodeEan128/UtilityBarcodeEan128.java b/ems-core/src/main/java/it/integry/ems_model/utility/BarcodeEan128/UtilityBarcodeEan128.java index a51f77cde8..81d02dcc4f 100644 --- a/ems-core/src/main/java/it/integry/ems_model/utility/BarcodeEan128/UtilityBarcodeEan128.java +++ b/ems-core/src/main/java/it/integry/ems_model/utility/BarcodeEan128/UtilityBarcodeEan128.java @@ -374,18 +374,8 @@ public class UtilityBarcodeEan128 { break; case COUNTRY_INITIAL_PROCESS: model.ShipToPostISO = convertToIsoValueModel(aiValue, 0, String.class, - new Callable() { - @Override - public String call(String input) { - return input; - } - }, - new CallableII() { - @Override - public String call(String input, Integer input2) { - return input; - } - }); + input -> input, + (input, input2) -> input); break; case COUNTRY_PROCESS: model.CountryProcess = aiValue; diff --git a/ems-core/src/test/java/EntityTestDefaultVal.java b/ems-core/src/test/java/EntityTestDefaultVal.java index c864db56dd..f2c4d8b9cf 100644 --- a/ems-core/src/test/java/EntityTestDefaultVal.java +++ b/ems-core/src/test/java/EntityTestDefaultVal.java @@ -19,7 +19,7 @@ public class EntityTestDefaultVal { public static void main(String[] args) throws Exception { EntityPropertyHolder holder = new EntityPropertyHolder(); - holder.scanEntityFields(); + holder.init(); Reflections reflections = new Reflections("it.integry.ems_model.entity"); Set> clssList = reflections.getSubTypesOf(EntityBase.class); diff --git a/ems-engine/src/main/java/it/integry/ems/production/service/MesProductionServiceV2.java b/ems-engine/src/main/java/it/integry/ems/production/service/MesProductionServiceV2.java index 2eca6f8f9b..734275a902 100644 --- a/ems-engine/src/main/java/it/integry/ems/production/service/MesProductionServiceV2.java +++ b/ems-engine/src/main/java/it/integry/ems/production/service/MesProductionServiceV2.java @@ -5,11 +5,13 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; import it.integry.common.var.CommonConstants; -import it.integry.ems.document.dto.*; +import it.integry.ems.document.dto.CaricoLavorazioneDTO; +import it.integry.ems.document.dto.ChiusuraLavorazioneDTO; +import it.integry.ems.document.dto.RientroLavorazioneDTO; +import it.integry.ems.document.dto.ScaricoLavorazioneDTO; import it.integry.ems.document.service.DocumentProdService; import it.integry.ems.exception.MissingDataException; import it.integry.ems.exception.PrimaryDatabaseNotPresentException; -import it.integry.ems.object_storage.minio.sdk.errors.MinioException; import it.integry.ems.production.dto.*; import it.integry.ems.report.dto.JasperDTO; import it.integry.ems.report.dto.PairsDTO; @@ -23,7 +25,6 @@ import it.integry.ems.utility.UtilityEntity; import it.integry.ems_model.base.EntityBase; import it.integry.ems_model.db.ResultSetMapper; import it.integry.ems_model.entity.*; -import it.integry.ems_model.exception.*; import it.integry.ems_model.service.SetupGest; import it.integry.ems_model.types.OperationType; import it.integry.ems_model.utility.*; @@ -35,16 +36,12 @@ import org.apache.pdfbox.printing.Orientation; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Service; -import org.xmlpull.v1.XmlPullParserException; import java.io.ByteArrayInputStream; import java.io.IOException; -import java.lang.reflect.InvocationTargetException; import java.math.BigDecimal; import java.math.RoundingMode; import java.net.HttpURLConnection; -import java.security.InvalidKeyException; -import java.security.NoSuchAlgorithmException; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; @@ -425,7 +422,7 @@ public class MesProductionServiceV2 { UtilityEntity.throwEntitiesException(UtilityEntity.toEntityBaseList(dtbOrdtList)); } - public void cambioFase(Date dataOrd, Integer numOrd, String gestioneOrd, String codJfas, Integer idStep, Integer idRiga, String newCodJfas) throws SQLException, IOException, PrimaryDatabaseNotPresentException, DataConverterNotFoundException, InstantiationException, IllegalAccessException, RulesNotCompiledException, MergeEntityDBToObjectException, MinioException, XmlPullParserException, NoSuchAlgorithmException, InvalidKeyException, NoSuchFieldException, FieldMissingException, InvocationTargetException, ConverterNotConfiguredException, EntityException { + public void cambioFase(Date dataOrd, Integer numOrd, String gestioneOrd, String codJfas, Integer idStep, Integer idRiga, String newCodJfas) throws Exception { String whereCondCodJfas = ""; String whereCondIdStep = ""; diff --git a/ems-engine/src/main/java/it/integry/ems/utility/controller/UtilityController.java b/ems-engine/src/main/java/it/integry/ems/utility/controller/UtilityController.java index 1b03e66a10..8bbc266359 100644 --- a/ems-engine/src/main/java/it/integry/ems/utility/controller/UtilityController.java +++ b/ems-engine/src/main/java/it/integry/ems/utility/controller/UtilityController.java @@ -59,8 +59,8 @@ public class UtilityController { @RequestMapping(value = EmsRestConstants.PATH_MERGE_PDF, method = RequestMethod.POST) public @ResponseBody ServiceRestResponse mergePDF(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String configuration, - @RequestBody List pdfList) { + @RequestParam(CommonConstants.PROFILE_DB) String configuration, + @RequestBody List pdfList) { ServiceRestResponse response = null; try { response = utilityService.mergePDF(pdfList); @@ -143,15 +143,8 @@ public class UtilityController { @RequestMapping(value = EmsRestConstants.PATH_DECODE_EAN_128, method = RequestMethod.GET) public @ResponseBody ServiceRestResponse decodeEan128(HttpServletRequest request, - @RequestParam("ean128") String ean128) { - ServiceRestResponse response; - try { - response = ServiceRestResponse.createPositiveResponse(UtilityBarcodeEan128.decode(ean128.getBytes())); - } catch (Exception e) { - logger.error(request.getRequestURI(), e); - response = new ServiceRestResponse(EsitoType.KO, "", e); - } - return response; + @RequestParam("ean128") String ean128) throws Exception { + return ServiceRestResponse.createPositiveResponse(UtilityBarcodeEan128.decode(ean128.getBytes())); } @RequestMapping(value = EmsRestConstants.PATH_SQL_TO_EXCEL, method = RequestMethod.POST) @@ -170,6 +163,7 @@ public class UtilityController { } return response; } + @RequestMapping(value = EmsRestConstants.PATH_READ_REMOTE_FILE, method = RequestMethod.POST) public @ResponseBody ServiceRestResponse readRemoteFile(@RequestBody JsonNode body) { @@ -248,8 +242,8 @@ public class UtilityController { @RequestMapping(value = EmsRestConstants.PATH_GET_RICORRENZE, method = RequestMethod.GET) public ServiceRestResponse getRicorrenze(HttpServletRequest request, - @RequestParam(CommonConstants.PROFILE_DB) String config, - @RequestParam(value = "anno") String anno) throws Exception { + @RequestParam(CommonConstants.PROFILE_DB) String config, + @RequestParam(value = "anno") String anno) throws Exception { try { return ServiceRestResponse.createPositiveResponse(utilityService.getRicorrenze(anno));