[NAE-2147] Merge 6.5.0 into 7.0.0

.github/workflows/nexus-release.yml

@@ -36,12 +36,20 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: DEBUG PRINT
+        run: echo "$MAVEN_USERNAME / $MAVEN_PASSWORD"
+        shell: bash
+        env:
+          MAVEN_USERNAME: ${{ secrets.NEXUS_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.NEXUS_PASSWORD }}
+
+
       - name: Set up Maven Central Repository
         uses: actions/setup-java@v4
         with:
           java-version: 21
           distribution: 'temurin'
-          server-id: netgrif-nexus-snapshots
+          server-id: netgrif-nexus-releases
           server-username: MAVEN_USERNAME
           server-password: MAVEN_PASSWORD
 

application-engine/CHANGELOG.md

@@ -5,7 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-Full Changelog: [https://github.com/netgrif/application-engine/commits/v7.0.0](https://github.com/netgrif/application-engine/commits/v7.0.0)
+- Full Changelog: [https://github.com/netgrif/application-engine/commits/v6.5.0](https://github.com/netgrif/application-engine/commits/v6.5.0)
+
+## [6.5.0](https://github.com/netgrif/application-engine/releases/tag/v6.5.0) (2025-02-18)
+
+### Added
+- [NAE-2033] Welcome dashboard
+
+### Changed
+- [NAE-2034] Open first view
+- [NAE-2051] Implement configurable view in menu items
+- [NAE-2039] Search in workflow view
+- [NAE-2052] Integrate ticket view with menu items
+
+- Full Changelog: [https://github.com/netgrif/application-engine/commits/v7.0.0](https://github.com/netgrif/application-engine/commits/v7.0.0)
 
 ## [7.0.0](https://github.com/netgrif/application-engine/releases/tag/v7.0.0) (2024-11-22)
 

application-engine/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy

@@ -248,6 +248,22 @@ class ImportHelper {
         superCreator.setAllToSuperUser()
     }
 
+    Optional<PetriNet> importProcess(String message, String netIdentifier, String netFileName) {
+        PetriNet filter = petriNetService.getNewestVersionByIdentifier(netIdentifier)
+        if (filter != null) {
+            log.info("${message} has already been imported.")
+            return Optional.of(filter)
+        }
+
+        Optional<PetriNet> filterNet = this.createNet(netFileName, VersionType.MAJOR, ActorTransformer.toLoggedUser(userService.getSystem()))
+
+        if (!filterNet.isPresent()) {
+            log.error("Import of ${message} failed!")
+        }
+
+        return filterNet
+    }
+
     static ObjectNode populateDataset(Map<String, Map<String, String>> data) {
         ObjectMapper mapper = new ObjectMapper()
         String json = mapper.writeValueAsString(data)

application-engine/src/main/java/com/netgrif/application/engine/elastic/service/ElasticPetriNetService.java

@@ -1,13 +1,39 @@
 package com.netgrif.application.engine.elastic.service;
 
+import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryStringQuery;
+import com.netgrif.application.engine.configuration.ElasticsearchConfiguration;
 import com.netgrif.application.engine.elastic.domain.ElasticPetriNetRepository;
 import com.netgrif.application.engine.elastic.service.executors.Executor;
 import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetService;
+import com.netgrif.application.engine.objects.auth.domain.LoggedUser;
 import com.netgrif.application.engine.objects.elastic.domain.ElasticPetriNet;
+import com.netgrif.application.engine.objects.petrinet.domain.PetriNet;
+import com.netgrif.application.engine.objects.petrinet.domain.PetriNetSearch;
+import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService;
+import com.netgrif.application.engine.petrinet.web.responsebodies.PetriNetReference;
+import com.netgrif.application.engine.utils.FullPageRequest;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
+import org.springframework.data.elasticsearch.client.elc.NativeQuery;
+import org.springframework.data.elasticsearch.client.elc.NativeQueryBuilder;
+import org.springframework.data.elasticsearch.core.SearchHitSupport;
+import org.springframework.data.elasticsearch.core.SearchHits;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.stereotype.Service;
 
+import java.util.*;
+import java.util.function.BinaryOperator;
+import java.util.stream.Collectors;
+
+import static org.springframework.data.elasticsearch.client.elc.Queries.termQuery;
+
 @Service
 @Slf4j
 public class ElasticPetriNetService implements IElasticPetriNetService {
@@ -16,9 +42,23 @@ public class ElasticPetriNetService implements IElasticPetriNetService {
 
     private final Executor executors;
 
-    public ElasticPetriNetService(ElasticPetriNetRepository repository, Executor executors) {
+    private IPetriNetService petriNetService;
+
+    private final ElasticsearchTemplate template;
+
+    protected ElasticsearchConfiguration elasticsearchConfiguration;
+
+    public ElasticPetriNetService(ElasticPetriNetRepository repository, Executor executors, ElasticsearchTemplate template, ElasticsearchConfiguration elasticsearchConfiguration) {
         this.repository = repository;
         this.executors = executors;
+        this.template = template;
+        this.elasticsearchConfiguration = elasticsearchConfiguration;
+    }
+
+    @Lazy
+    @Autowired
+    public void setPetriNetService(IPetriNetService petriNetService) {
+        this.petriNetService = petriNetService;
     }
 
     @Override
@@ -54,4 +94,111 @@ public void remove(String id) {
             log.info("[" + id + "]: PetriNet \"" + id + "\" deleted");
         });
     }
+
+    /**
+     * Method for search of PetriNets in Elastic
+     *
+     * @param requests       - search body, for now only title working
+     * @param user           - logged user
+     * @param pageable       - pageable for paging
+     * @param locale         - internacionalization
+     * @param isIntersection - property for merging filter, not implemented now, use false
+     * @return Page<PetriNetReference> - page of PetriNetReferences
+     */
+    @Override
+    public Page<PetriNetReference> search(PetriNetSearch requests, LoggedUser user, Pageable pageable, Locale locale, Boolean isIntersection) {
+        if (requests == null) {
+            throw new IllegalArgumentException("Request can not be null!");
+        }
+        log.debug("Searching for PetriNet query with logged user [{}]", user.getId());
+        // TODO: impersonation
+//        LoggedUser loggedOrImpersonated = user.getSelfOrImpersonated();
+        LoggedUser loggedOrImpersonated = user;
+        NativeQuery query = buildQuery(requests, loggedOrImpersonated, pageable, locale, isIntersection);
+        List<PetriNet> netPage;
+        long total;
+        if (query != null) {
+            SearchHits<ElasticPetriNet> hits = template.search(query, ElasticPetriNet.class, IndexCoordinates.of(elasticsearchConfiguration.elasticPetriNetIndex()));
+            Page<ElasticPetriNet> indexedNets = (Page) SearchHitSupport.unwrapSearchHits(SearchHitSupport.searchPageFor(hits, query.getPageable()));
+            netPage = petriNetService.findAllById(indexedNets.get().map(ElasticPetriNet::getStringId).collect(Collectors.toList()));
+            total = indexedNets.getTotalElements();
+            log.debug("Found [{}] total elements of page [{}]", netPage.size(), pageable.getPageNumber());
+        } else {
+            netPage = Collections.emptyList();
+            total = 0;
+        }
+
+        return new PageImpl<>(netPage.stream().map(net -> new PetriNetReference(net, locale)).collect(Collectors.toList()), pageable, total);
+    }
+
+    protected NativeQuery buildQuery(PetriNetSearch request, LoggedUser user, Pageable pageable, Locale locale, Boolean isIntersection) {
+        List<BoolQuery.Builder> singleQueries = new LinkedList<>();
+        singleQueries.add(buildSingleQuery(request, user, locale));
+
+        if (isIntersection && !singleQueries.stream().allMatch(Objects::nonNull)) {
+            // one of the queries evaluates to empty set => the entire result is an empty set
+            return null;
+        } else if (!isIntersection) {
+            singleQueries = singleQueries.stream().filter(Objects::nonNull).collect(Collectors.toList());
+            if (singleQueries.isEmpty()) {
+                // all queries result in an empty set => the entire result is an empty set
+                return null;
+            }
+        }
+
+        BinaryOperator<BoolQuery.Builder> reductionOperation = isIntersection ? (a, b) -> a.must(b.build()._toQuery()) : (a, b) -> a.should(b.build()._toQuery());
+        BoolQuery.Builder query = singleQueries.stream().reduce(new BoolQuery.Builder(), reductionOperation);
+
+        NativeQueryBuilder builder = new NativeQueryBuilder();
+        return builder
+                .withQuery(query.build()._toQuery())
+                .withPageable(pageable)
+                .build();
+    }
+
+    protected BoolQuery.Builder buildSingleQuery(PetriNetSearch request, LoggedUser user, Locale locale) {
+        BoolQuery.Builder query = new BoolQuery.Builder();
+
+        buildFullTextQuery(request, query);
+        boolean resultAlwaysEmpty = buildGroupQuery(request, user, locale, query);
+        if (resultAlwaysEmpty) {
+            return null;
+        }
+        return query;
+    }
+
+    protected void buildFullTextQuery(PetriNetSearch request, BoolQuery.Builder query) {
+        if (request.getTitle() == null || request.getTitle().isEmpty()) {
+            return;
+        }
+
+        // TODO refactor to properties
+        String searchText = "*" + request.getTitle() + "*";
+        List<String> fullTextFields = List.of(
+                "title.textValue^2",
+                "identifier^1"
+        );
+
+        QueryStringQuery fullTextQuery = QueryStringQuery.of(builder -> builder.fields(fullTextFields).query(searchText));
+        query.must(fullTextQuery._toQuery());
+    }
+
+    protected boolean buildGroupQuery(PetriNetSearch request, LoggedUser user, Locale locale, BoolQuery.Builder query) {
+        if (request.getGroup() == null || request.getGroup().isEmpty()) {
+            return false;
+        }
+
+        PetriNetSearch processQuery = new PetriNetSearch();
+        processQuery.setGroup(request.getGroup());
+        List<PetriNetReference> groupProcesses = this.petriNetService.search(processQuery, user, new FullPageRequest(), locale).getContent();
+        if (groupProcesses.isEmpty())
+            return true;
+
+        BoolQuery.Builder groupQuery = new BoolQuery.Builder();
+        groupProcesses.stream().map(PetriNetReference::getIdentifier)
+                .map(netIdentifier -> termQuery("identifier", netIdentifier))
+                .forEach(termQuery -> groupQuery.should(termQuery._toQuery()));
+        query.filter(groupQuery.build()._toQuery());
+        return false;
+    }
 }

application-engine/src/main/java/com/netgrif/application/engine/elastic/service/interfaces/IElasticPetriNetService.java

@@ -1,8 +1,15 @@
 package com.netgrif.application.engine.elastic.service.interfaces;
 
+import com.netgrif.application.engine.objects.auth.domain.LoggedUser;
 import com.netgrif.application.engine.objects.elastic.domain.ElasticPetriNet;
+import com.netgrif.application.engine.objects.petrinet.domain.PetriNetSearch;
+import com.netgrif.application.engine.petrinet.web.responsebodies.PetriNetReference;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.scheduling.annotation.Async;
 
+import java.util.Locale;
+
 public interface IElasticPetriNetService {
 
     @Async
@@ -11,4 +18,7 @@ public interface IElasticPetriNetService {
     void indexNow(ElasticPetriNet net);
 
     void remove(String id);
+
+    Page<PetriNetReference> search(PetriNetSearch requests, LoggedUser user, Pageable pageable, Locale locale, Boolean isIntersection);
+
 }

application-engine/src/main/java/com/netgrif/application/engine/menu/services/DashboardItemServiceImpl.java

@@ -0,0 +1,126 @@
+package com.netgrif.application.engine.menu.services;
+
+
+import com.netgrif.application.engine.auth.service.UserService;
+import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService;
+import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest;
+import com.netgrif.application.engine.menu.services.interfaces.DashboardItemService;
+import com.netgrif.application.engine.objects.auth.domain.AbstractUser;
+import com.netgrif.application.engine.objects.auth.domain.ActorTransformer;
+import com.netgrif.application.engine.objects.auth.domain.LoggedUser;
+import com.netgrif.application.engine.objects.petrinet.domain.throwable.TransitionNotExecutableException;
+import com.netgrif.application.engine.objects.utils.MenuItemUtils;
+import com.netgrif.application.engine.objects.workflow.domain.Case;
+import com.netgrif.application.engine.objects.workflow.domain.Task;
+import com.netgrif.application.engine.objects.workflow.domain.menu.ToDataSetOutcome;
+import com.netgrif.application.engine.objects.workflow.domain.menu.dashboard.DashboardItemBody;
+import com.netgrif.application.engine.objects.workflow.domain.menu.dashboard.DashboardItemConstants;
+import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService;
+import com.netgrif.application.engine.startup.ImportHelper;
+import com.netgrif.application.engine.workflow.service.interfaces.IDataService;
+import com.netgrif.application.engine.workflow.service.interfaces.ITaskService;
+import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class DashboardItemServiceImpl implements DashboardItemService {
+
+    protected final IWorkflowService workflowService;
+    protected final UserService userService;
+    protected final ITaskService taskService;
+    protected final IDataService dataService;
+    protected final IPetriNetService petriNetService;
+    protected final IElasticCaseService elasticCaseService;
+
+    /**
+     * Creates a new dashboard item case if it does not already exist.
+     * If a case with the same ID is found, it is returned instead of creating a new one.
+     *
+     * @param body The {@link DashboardItemBody} containing data for the dashboard item.
+     * @return The created or existing {@link Case} representing the dashboard item.
+     * @throws TransitionNotExecutableException if the task transition is not executable.
+     */
+    @Override
+    public Case getOrCreate(DashboardItemBody body) throws TransitionNotExecutableException {
+        MenuItemUtils.sanitize(body.getId());
+        Case itemCase;
+
+        itemCase = findById(body.getId());
+        if (itemCase != null) {
+            log.info("Dashboard item with id:{} already exists", body.getId());
+            return itemCase;
+        }
+
+        LoggedUser loggedUser = ActorTransformer.toLoggedUser(userService.getLoggedOrSystem());
+        itemCase = workflowService.createCase(petriNetService.getNewestVersionByIdentifier(DashboardItemConstants.PROCESS_IDENTIFIER).getStringId(), body.getName().getDefaultValue(), "", loggedUser).getCase();
+        ToDataSetOutcome outcome = body.toDataSet();
+        itemCase = setDataWithExecute(itemCase, DashboardItemConstants.TASK_CONFIGURE, outcome.getDataSet());
+        return itemCase;
+    }
+
+
+    /**
+     * Updates an existing dashboard item case with new data.
+     *
+     * @param itemCase The existing {@link Case} to update.
+     * @param body The {@link DashboardItemBody} containing updated data.
+     * @return The updated {@link Case} representing the dashboard item.
+     * @throws TransitionNotExecutableException if the task transition is not executable.
+     */
+    @Override
+    public Case update(Case itemCase, DashboardItemBody body) throws TransitionNotExecutableException {
+        MenuItemUtils.sanitize(body.getId());
+        ToDataSetOutcome outcome = body.toDataSet();
+        itemCase = setDataWithExecute(itemCase, DashboardItemConstants.TASK_CONFIGURE, outcome.getDataSet());
+        return itemCase;
+    }
+
+    /**
+     * Finds an existing dashboard item case by its identifier.
+     *
+     * @param identifier The unique identifier of the dashboard item.
+     * @return The {@link Case} representing the dashboard item, or null if not found.
+     */
+    @Override
+    public Case findById(String identifier) {
+        String query = String.format("processIdentifier:%s AND dataSet.%s.textValue.keyword:\"%s\"",
+                DashboardItemConstants.PROCESS_IDENTIFIER, DashboardItemConstants.FIELD_ID, identifier);
+        return findCase(DashboardItemConstants.PROCESS_IDENTIFIER, query);
+    }
+
+    protected Case setData(Case useCase, String transId, Map<String, Map<String, Object>> dataSet) {
+        String taskId = MenuItemUtils.findTaskIdInCase(useCase, transId);
+        return dataService.setData(taskId, ImportHelper.populateDataset((Map) dataSet)).getCase();
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    protected Case setDataWithExecute(Case useCase, String transId, Map<String, Map<String, Object>> dataSet) throws TransitionNotExecutableException {
+        AbstractUser loggedUser = userService.getLoggedOrSystem();
+        String taskId = MenuItemUtils.findTaskIdInCase(useCase, transId);
+        Task task = taskService.findOne(taskId);
+        task = taskService.assignTask(task, loggedUser).getTask();
+        task = dataService.setData(task, ImportHelper.populateDataset((Map) dataSet)).getTask();
+        return taskService.finishTask(task, loggedUser).getCase();
+    }
+
+    protected Case findCase(String processIdentifier, String query) {
+        CaseSearchRequest request = CaseSearchRequest.builder()
+                .process(Collections.singletonList(new CaseSearchRequest.PetriNet(processIdentifier)))
+                .query(query)
+                .build();
+        Page<Case> resultPage = elasticCaseService.search(java.util.List.of(request), ActorTransformer.toLoggedUser(userService.getLoggedOrSystem()),
+                PageRequest.of(0, 1), Locale.getDefault(), false);
+
+        return resultPage.hasContent() ? resultPage.getContent().get(0) : null;
+    }
+}