Complete ServerRecordFinder class

ServerRecordFinder.java

import demo.entities.ServerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.persistence.EntityManager;
import javax.persistence.Tuple;
import javax.persistence.TupleElement;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Selection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class ServerRecordFinder {

    private final EntityManager entityManager;

    @Autowired
    public ServerRecordFinder(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public List<ServerRecord> getRecords(EntityManager entityManager) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Tuple> tupleCriteriaQuery = criteriaBuilder.createTupleQuery();
        Root<ServerRecord> root = tupleCriteriaQuery.from(ServerRecord.class);

        // select
        List<Expression<?>> selectExpressionList = getSelectedColumns(root);
        List<Selection<?>> selectClauses = new ArrayList<>(selectExpressionList);
        tupleCriteriaQuery.multiselect(selectClauses);

        // where
        tupleCriteriaQuery.where(criteriaBuilder.equal(root.get("user"), "xyz")); // simulate user input

        // group by
        // combine the group by values with the select values given by the user
        List<Expression<?>> groupByListResult = new ArrayList<>(selectExpressionList);
        // simulate group by, in real scenario it is provided by the user
        groupByListResult.add(root.get("date"));
        tupleCriteriaQuery.groupBy(groupByListResult);

        TypedQuery<Tuple> query = entityManager.createQuery(tupleCriteriaQuery);
        List<Tuple> queryResultList = query.getResultList();

        Set<String> resultColumns = getResultColumnsByAlias(queryResultList);

        // map tuple result to entity
        return  queryResultList.stream().map(tuple -> mapToRecord(resultColumns, tuple)).collect(Collectors.toList());

    }

    private ServerRecord mapToRecord (Set<String> resultColumns, Tuple tuple ) {
        ServerRecord serverRecord = new ServerRecord();
        serverRecord.setUser((String) getValueByColumnName(resultColumns, tuple, "user"));
        serverRecord.setTimestamp((String) getValueByColumnName(resultColumns, tuple, "timestamp"));
        serverRecord.setDate((String) getValueByColumnName(resultColumns, tuple, "date"));
        serverRecord.setInstances((Integer) getValueByColumnName(resultColumns, tuple, "instances"));
        serverRecord.setStatus((String) getValueByColumnName(resultColumns, tuple, "status"));
        return serverRecord;
    }

    private Set<String> getResultColumnsByAlias(List<Tuple> queryResultList) {
        return queryResultList.stream()
                .map(Tuple::getElements)
                .collect(Collectors.toList()).stream()
                .flatMap(Collection::stream)
                .map(TupleElement::getAlias)
                .collect(Collectors.toSet());
    }

    private static Object getValueByColumnName(Set<String> selectedResultColumns, Tuple tuple, String columnName) {
        if (selectedResultColumns.contains(columnName)) {
            return tuple.get(columnName);
        } else {
            return null;
        }
    }

    private List<Expression<?>> getSelectedColumns(Root<ServerRecord> root) {
        List<Expression<?>> selectedColumns = new ArrayList<>();
        // Simulate adding select values. In real scenario these values come dynamically, e.g. from the user input
        selectedColumns.add((Expression<?>) root.get("timestamp").alias("timestamp"));
        selectedColumns.add((Expression<?>) root.get("user").alias("user"));
        return selectedColumns;
    }
}