2018-06-27 12:29:21 +02:00
|
|
|
package eu.eudat.logic.managers;
|
2017-12-14 18:07:09 +01:00
|
|
|
|
2020-07-31 11:20:29 +02:00
|
|
|
import eu.eudat.data.dao.criteria.DataManagementPlanCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.DatasetCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.GrantCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.OrganisationCriteria;
|
2018-03-21 11:57:56 +01:00
|
|
|
import eu.eudat.data.dao.entities.DMPDao;
|
|
|
|
import eu.eudat.data.dao.entities.DatasetDao;
|
2019-07-31 16:57:34 +02:00
|
|
|
import eu.eudat.data.dao.entities.GrantDao;
|
2020-07-31 11:20:29 +02:00
|
|
|
import eu.eudat.data.dao.entities.OrganisationDao;
|
2022-02-21 16:16:32 +01:00
|
|
|
import eu.eudat.data.entities.DMP;
|
|
|
|
import eu.eudat.data.entities.Dataset;
|
|
|
|
import eu.eudat.data.entities.Grant;
|
|
|
|
import eu.eudat.data.entities.UserInfo;
|
2021-08-04 17:38:49 +02:00
|
|
|
import eu.eudat.data.query.items.table.dataset.DatasetTableRequest;
|
2022-02-21 16:16:32 +01:00
|
|
|
import eu.eudat.data.query.items.table.dmp.DataManagementPlanTableRequest;
|
2018-08-24 17:21:02 +02:00
|
|
|
import eu.eudat.logic.builders.model.models.RecentActivityDataBuilder;
|
|
|
|
import eu.eudat.logic.services.ApiContext;
|
2019-03-05 16:33:59 +01:00
|
|
|
import eu.eudat.logic.services.operations.DatabaseRepository;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.dashboard.recent.RecentActivity;
|
|
|
|
import eu.eudat.models.data.dashboard.recent.RecentActivityData;
|
2020-06-30 15:59:06 +02:00
|
|
|
import eu.eudat.models.data.dashboard.recent.model.RecentActivityModel;
|
|
|
|
import eu.eudat.models.data.dashboard.recent.model.RecentDatasetModel;
|
|
|
|
import eu.eudat.models.data.dashboard.recent.model.RecentDmpModel;
|
2020-07-03 09:43:19 +02:00
|
|
|
import eu.eudat.models.data.dashboard.recent.tablerequest.RecentActivityTableRequest;
|
2018-08-24 17:21:02 +02:00
|
|
|
import eu.eudat.models.data.dashboard.searchbar.SearchBarItem;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.dashboard.statistics.DashBoardStatistics;
|
2022-02-21 16:16:32 +01:00
|
|
|
import eu.eudat.models.data.helpers.common.DataTableData;
|
2021-08-04 17:38:49 +02:00
|
|
|
import eu.eudat.models.data.listingmodels.DataManagementPlanListingModel;
|
|
|
|
import eu.eudat.models.data.listingmodels.DatasetListingModel;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.security.Principal;
|
2018-08-24 17:21:02 +02:00
|
|
|
import eu.eudat.types.searchbar.SearchBarItemType;
|
2020-03-30 14:33:30 +02:00
|
|
|
import org.slf4j.Logger;
|
|
|
|
import org.slf4j.LoggerFactory;
|
2019-03-05 16:33:59 +01:00
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
|
import org.springframework.stereotype.Component;
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2020-06-30 15:59:06 +02:00
|
|
|
import javax.transaction.Transactional;
|
2020-03-18 10:22:10 +01:00
|
|
|
import java.io.IOException;
|
2021-10-12 14:41:20 +02:00
|
|
|
import java.lang.reflect.InvocationTargetException;
|
2020-06-30 15:59:06 +02:00
|
|
|
import java.util.*;
|
2018-03-19 13:40:04 +01:00
|
|
|
import java.util.concurrent.CompletableFuture;
|
2020-03-18 10:22:10 +01:00
|
|
|
import java.util.stream.Collectors;
|
2020-07-03 09:43:19 +02:00
|
|
|
import java.util.stream.Stream;
|
2018-02-02 11:33:37 +01:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
@Component
|
2017-12-14 18:07:09 +01:00
|
|
|
public class DashBoardManager {
|
2020-03-30 14:33:30 +02:00
|
|
|
private static final Logger logger = LoggerFactory.getLogger(DashBoardManager.class);
|
2018-02-02 11:33:37 +01:00
|
|
|
|
2020-07-03 09:43:19 +02:00
|
|
|
private final Map<String, Comparator<RecentActivityModel>> comparators = Stream.of(new Object[][] {
|
2020-07-03 12:55:25 +02:00
|
|
|
{ "modified", Comparator.comparing(o -> ((RecentActivityModel)o).getModified()).reversed()},
|
|
|
|
{ "created", Comparator.comparing(o -> ((RecentActivityModel)o).getCreated()).reversed()},
|
2020-07-03 09:43:19 +02:00
|
|
|
{ "label", Comparator.comparing(o -> ((RecentActivityModel)o).getTitle())},
|
2020-07-31 12:21:01 +02:00
|
|
|
{ "status", Comparator.comparing(o -> ((RecentActivityModel)o).getStatus()).reversed()},
|
2020-07-31 16:04:18 +02:00
|
|
|
{ "finalizedAt", Comparator.comparing(o -> ((RecentActivityModel)o).getFinalizedAt(), Comparator.nullsLast(Comparator.naturalOrder())).reversed()},
|
|
|
|
{ "publishedAt", Comparator.comparing(o -> ((RecentActivityModel)o).getPublishedAt(), Comparator.nullsLast(Comparator.naturalOrder())).reversed()}
|
2020-07-03 09:43:19 +02:00
|
|
|
}).collect(Collectors.toMap(data -> (String) data[0], data -> (Comparator<RecentActivityModel>)data[1]));
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
private ApiContext apiContext;
|
|
|
|
private DatabaseRepository databaseRepository;
|
2022-02-21 16:16:32 +01:00
|
|
|
private final DataManagementPlanManager dataManagementPlanManager;
|
|
|
|
private final DatasetManager datasetManager;
|
2019-03-05 16:33:59 +01:00
|
|
|
|
|
|
|
@Autowired
|
2022-02-21 16:16:32 +01:00
|
|
|
public DashBoardManager(ApiContext apiContext, DataManagementPlanManager dataManagementPlanManager, DatasetManager datasetManager) {
|
2019-03-05 16:33:59 +01:00
|
|
|
this.apiContext = apiContext;
|
|
|
|
this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
|
2022-02-21 16:16:32 +01:00
|
|
|
this.dataManagementPlanManager = dataManagementPlanManager;
|
|
|
|
this.datasetManager = datasetManager;
|
2019-03-05 16:33:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public DashBoardStatistics getStatistics() {
|
2018-02-02 11:33:37 +01:00
|
|
|
DashBoardStatistics statistics = new DashBoardStatistics();
|
2019-05-15 17:39:05 +02:00
|
|
|
|
2020-07-31 11:20:29 +02:00
|
|
|
DataManagementPlanCriteria publicCriteria = new DataManagementPlanCriteria();
|
|
|
|
publicCriteria.setIsPublic(true);
|
|
|
|
publicCriteria.setOnlyPublic(true);
|
2020-03-18 10:22:10 +01:00
|
|
|
publicCriteria.setAllVersions(false);
|
|
|
|
|
2020-07-31 11:20:29 +02:00
|
|
|
List<DMP> dmps = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(publicCriteria).toList();
|
2020-03-18 10:22:10 +01:00
|
|
|
|
|
|
|
// DataManagementPlanCriteria dataManagementPlanCriteria = new DataManagementPlanCriteria();
|
2019-05-15 17:39:05 +02:00
|
|
|
OrganisationCriteria organisationCriteria = new OrganisationCriteria();
|
2020-03-18 10:22:10 +01:00
|
|
|
/*dataManagementPlanCriteria.setAllVersions(false);
|
|
|
|
dataManagementPlanCriteria.setIsPublic(true);*/
|
2019-09-18 15:16:14 +02:00
|
|
|
organisationCriteria.setPublic(true);
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2020-03-18 10:22:10 +01:00
|
|
|
// List<DMP> dmps = databaseRepository.getDmpDao().getWithCriteria(dataManagementPlanCriteria).toList();
|
2019-09-18 15:16:14 +02:00
|
|
|
long numberOfDatasets = 0;
|
|
|
|
LinkedList<Grant> grants = new LinkedList<>();
|
|
|
|
for (DMP dmp : dmps) {
|
|
|
|
numberOfDatasets = numberOfDatasets + dmp.getDataset().stream()
|
|
|
|
.filter(item -> item.getStatus() == Dataset.Status.FINALISED.getValue()).count();
|
|
|
|
grants.add(dmp.getGrant());
|
|
|
|
}
|
|
|
|
|
|
|
|
statistics.setTotalDataManagementPlanCount((long) dmps.size());
|
|
|
|
statistics.setTotalDataSetCount(numberOfDatasets);
|
|
|
|
statistics.setTotalGrantCount(grants.stream().distinct().count());
|
|
|
|
statistics.setTotalOrganisationCount(databaseRepository.getOrganisationDao().getWithCriteria(organisationCriteria).count());
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2018-02-02 11:33:37 +01:00
|
|
|
return statistics;
|
|
|
|
}
|
|
|
|
|
2020-03-18 10:22:10 +01:00
|
|
|
public DashBoardStatistics getMeStatistics(Principal principal) throws IOException {
|
2021-08-04 17:38:49 +02:00
|
|
|
Long datasets = 0L;
|
|
|
|
Long dmps = 0L;
|
2018-02-02 11:33:37 +01:00
|
|
|
DashBoardStatistics statistics = new DashBoardStatistics();
|
2019-03-05 16:33:59 +01:00
|
|
|
DMPDao dataManagementPlanRepository = databaseRepository.getDmpDao();
|
|
|
|
DatasetDao datasetRepository = databaseRepository.getDatasetDao();
|
2019-07-31 16:57:34 +02:00
|
|
|
GrantDao grantRepository = databaseRepository.getGrantDao();
|
2019-04-22 16:19:08 +02:00
|
|
|
OrganisationDao organisationRepository = databaseRepository.getOrganisationDao();
|
2018-02-02 11:33:37 +01:00
|
|
|
UserInfo user = new UserInfo();
|
|
|
|
user.setId(principal.getId());
|
2018-03-19 13:40:04 +01:00
|
|
|
DatasetCriteria datasetCriteria = new DatasetCriteria();
|
2020-04-01 17:16:06 +02:00
|
|
|
if (apiContext.getOperationsContext().getElasticRepository().getDatasetRepository() != null) {
|
2020-03-30 14:33:30 +02:00
|
|
|
try {
|
|
|
|
eu.eudat.elastic.criteria.DatasetCriteria datasetElasticCriteria = new eu.eudat.elastic.criteria.DatasetCriteria();
|
|
|
|
datasetElasticCriteria.setAllowAllVersions(false);
|
|
|
|
datasetElasticCriteria.setPublic(false);
|
2021-08-04 17:38:49 +02:00
|
|
|
datasetElasticCriteria.setCollaborators(Collections.singletonList(principal.getId()));
|
|
|
|
datasets = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().count(datasetElasticCriteria);
|
2020-03-30 14:33:30 +02:00
|
|
|
}catch (Exception e) {
|
|
|
|
logger.warn(e.getMessage(), e);
|
|
|
|
datasets = null;
|
|
|
|
}
|
2020-03-18 10:22:10 +01:00
|
|
|
}
|
2018-03-19 13:40:04 +01:00
|
|
|
datasetCriteria.setAllVersions(false);
|
2020-03-16 17:50:29 +01:00
|
|
|
datasetCriteria.setIsPublic(false);
|
2018-03-19 13:40:04 +01:00
|
|
|
DataManagementPlanCriteria dataManagementPlanCriteria = new DataManagementPlanCriteria();
|
2020-04-07 17:41:25 +02:00
|
|
|
if (apiContext.getOperationsContext().getElasticRepository().getDmpRepository() != null) {
|
|
|
|
try {
|
|
|
|
eu.eudat.elastic.criteria.DmpCriteria dmpElasticCriteria = new eu.eudat.elastic.criteria.DmpCriteria();
|
|
|
|
dmpElasticCriteria.setAllowAllVersions(false);
|
|
|
|
dmpElasticCriteria.setPublic(false);
|
2021-08-04 17:38:49 +02:00
|
|
|
dmpElasticCriteria.setCollaborators(Collections.singletonList(principal.getId()));
|
|
|
|
dmps = apiContext.getOperationsContext().getElasticRepository().getDmpRepository().count(dmpElasticCriteria);
|
2020-04-07 17:41:25 +02:00
|
|
|
}catch (Exception e) {
|
|
|
|
logger.warn(e.getMessage(), e);
|
|
|
|
dmps = null;
|
|
|
|
}
|
|
|
|
}
|
2018-03-19 13:40:04 +01:00
|
|
|
dataManagementPlanCriteria.setAllVersions(false);
|
2021-08-04 17:38:49 +02:00
|
|
|
dataManagementPlanCriteria.setOnlyPublic(false);
|
|
|
|
dataManagementPlanCriteria.setIsPublic(false);
|
2019-03-15 17:06:55 +01:00
|
|
|
|
2021-08-04 17:38:49 +02:00
|
|
|
GrantCriteria grantCriteria = new GrantCriteria();
|
2021-05-10 16:17:08 +02:00
|
|
|
grantCriteria.setActive(true);
|
|
|
|
|
2021-07-19 17:34:29 +02:00
|
|
|
OrganisationCriteria organisationCriteria = new OrganisationCriteria();
|
|
|
|
organisationCriteria.setActive(true);
|
|
|
|
|
2019-09-26 11:44:39 +02:00
|
|
|
List<Integer> roles = new LinkedList<>();
|
2021-08-04 17:38:49 +02:00
|
|
|
if ((dmps == null || dmps == 0L) && (datasets == null || datasets == 0L)) {
|
|
|
|
CompletableFuture dmpFuture = dataManagementPlanRepository.getAuthenticated(dataManagementPlanRepository.getWithCriteria(dataManagementPlanCriteria), principal.getId(), roles).distinct().countAsync()
|
|
|
|
.whenComplete((dmpsStats, throwable) -> statistics.setTotalDataManagementPlanCount(dmpsStats));
|
2021-11-24 15:23:02 +01:00
|
|
|
CompletableFuture datasetFuture = datasetRepository.getAuthenticated( datasetRepository.getWithCriteria(datasetCriteria), user, roles).distinct().countAsync()
|
2021-08-04 17:38:49 +02:00
|
|
|
.whenComplete((datasetsStats, throwable) -> statistics.setTotalDataSetCount(datasetsStats));
|
|
|
|
CompletableFuture.allOf(dmpFuture, datasetFuture).join();
|
|
|
|
} else {
|
|
|
|
statistics.setTotalDataManagementPlanCount(dmps);
|
|
|
|
statistics.setTotalDataSetCount(datasets);
|
|
|
|
}
|
2019-07-31 16:57:34 +02:00
|
|
|
CompletableFuture grantFuture = grantRepository.getAuthenticated(grantRepository.getWithCriteria(grantCriteria), user).countAsync()
|
|
|
|
.whenComplete((grantsStats, throwable) -> statistics.setTotalGrantCount(grantsStats));
|
2021-07-19 17:34:29 +02:00
|
|
|
CompletableFuture orgnanisationFuture = organisationRepository.getAuthenticated(organisationRepository.getWithCriteria(organisationCriteria).withHint("organisationRecentActivity"), user).countAsync()
|
2019-04-22 16:19:08 +02:00
|
|
|
.whenComplete((organisationStats, throwable) -> statistics.setTotalOrganisationCount(organisationStats));
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2021-08-04 17:38:49 +02:00
|
|
|
CompletableFuture.allOf( grantFuture, orgnanisationFuture).join();
|
2018-02-02 11:33:37 +01:00
|
|
|
return statistics;
|
|
|
|
}
|
2017-12-14 18:07:09 +01:00
|
|
|
|
2021-11-24 15:23:02 +01:00
|
|
|
@Deprecated
|
2019-03-05 16:33:59 +01:00
|
|
|
public RecentActivity getRecentActivity(Principal principal, Integer numberofactivities) {
|
2018-03-19 13:40:04 +01:00
|
|
|
RecentActivity activity = new RecentActivity();
|
2019-03-05 16:33:59 +01:00
|
|
|
DMPDao dataManagementPlanRepository = databaseRepository.getDmpDao();
|
|
|
|
DatasetDao datasetRepository = databaseRepository.getDatasetDao();
|
2019-07-31 16:57:34 +02:00
|
|
|
GrantDao grantRepository = databaseRepository.getGrantDao();
|
2018-03-19 13:40:04 +01:00
|
|
|
UserInfo user = new UserInfo();
|
|
|
|
user.setId(principal.getId());
|
2018-08-27 17:09:33 +02:00
|
|
|
DatasetCriteria datasetCriteria = new DatasetCriteria();
|
|
|
|
datasetCriteria.setAllVersions(false);
|
|
|
|
DataManagementPlanCriteria dataManagementPlanCriteria = new DataManagementPlanCriteria();
|
|
|
|
dataManagementPlanCriteria.setAllVersions(false);
|
2019-07-31 16:57:34 +02:00
|
|
|
GrantCriteria grantCriteria = new GrantCriteria();
|
2018-03-19 13:40:04 +01:00
|
|
|
RecentActivityDataBuilder recentActivityDataBuilder = apiContext.getOperationsContext().getBuilderFactory().getBuilder(RecentActivityDataBuilder.class);
|
|
|
|
|
2019-09-26 11:44:39 +02:00
|
|
|
List<Integer> roles = new LinkedList<>();
|
|
|
|
CompletableFuture<List<RecentActivityData>> dmps = dataManagementPlanRepository.getAuthenticated(dataManagementPlanRepository.getWithCriteria(dataManagementPlanCriteria), principal.getId(), roles)
|
2018-03-19 13:40:04 +01:00
|
|
|
.withHint("dmpRecentActivity")
|
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.take(numberofactivities)
|
2018-05-28 11:50:42 +02:00
|
|
|
.selectAsync(item -> recentActivityDataBuilder.label(item.getLabel()).timestamp(item.getModified()).id(item.getId().toString()).build())
|
|
|
|
.whenComplete((dmpActivities, throwable) -> activity.setRecentDmpActivities(dmpActivities));
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2021-11-24 15:23:02 +01:00
|
|
|
CompletableFuture<List<RecentActivityData>> datasets = datasetRepository.getAuthenticated(datasetRepository.getWithCriteria(datasetCriteria), user, roles).distinct()
|
2018-03-19 13:40:04 +01:00
|
|
|
.withHint("datasetRecentActivity")
|
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.take(numberofactivities)
|
2018-05-28 11:50:42 +02:00
|
|
|
.selectAsync(item -> recentActivityDataBuilder.label(item.getLabel()).timestamp(item.getModified()).id(item.getId().toString()).build())
|
|
|
|
.whenComplete((datasetActivities, throwable) -> activity.setRecentDatasetActivities(datasetActivities));
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2021-08-04 17:38:49 +02:00
|
|
|
CompletableFuture<List<RecentActivityData>> grants = grantRepository.getAuthenticated(grantRepository.getWithCriteria(grantCriteria), user)
|
2019-07-31 16:57:34 +02:00
|
|
|
.withHint("grantRecentActivity")
|
2018-03-19 13:40:04 +01:00
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.take(numberofactivities)
|
2018-05-28 11:50:42 +02:00
|
|
|
.selectAsync(item -> recentActivityDataBuilder.label(item.getLabel()).timestamp(item.getModified()).id(item.getId().toString()).build())
|
2021-08-04 17:38:49 +02:00
|
|
|
.whenComplete((grantActivities, throwable) -> activity.setRecentGrantActivities(grantActivities));
|
2018-03-19 13:40:04 +01:00
|
|
|
|
2021-08-04 17:38:49 +02:00
|
|
|
CompletableFuture.allOf(grants, dmps, datasets).join();
|
2018-03-19 13:40:04 +01:00
|
|
|
return activity;
|
|
|
|
}
|
|
|
|
|
2020-06-30 15:59:06 +02:00
|
|
|
@Transactional
|
2022-02-21 16:16:32 +01:00
|
|
|
public List<RecentActivityModel> getNewRecentActivity(RecentActivityTableRequest tableRequest, Principal principal) throws Exception {
|
2020-07-24 11:12:54 +02:00
|
|
|
boolean isAuthenticated = principal.getId() != null;
|
2022-02-21 16:16:32 +01:00
|
|
|
List<RecentActivityModel> recentActivityModels = new ArrayList<>();
|
2020-06-30 15:59:06 +02:00
|
|
|
UserInfo user = new UserInfo();
|
2020-07-31 12:16:29 +02:00
|
|
|
if (isAuthenticated) {
|
|
|
|
user.setId(principal.getId());
|
|
|
|
}
|
2020-06-30 15:59:06 +02:00
|
|
|
DatasetCriteria datasetCriteria = new DatasetCriteria();
|
2020-07-03 09:43:19 +02:00
|
|
|
datasetCriteria.setLike(tableRequest.getCriteria().getLike());
|
2020-06-30 15:59:06 +02:00
|
|
|
datasetCriteria.setAllVersions(false);
|
2020-07-24 11:12:54 +02:00
|
|
|
datasetCriteria.setIsPublic(!isAuthenticated);
|
2020-06-30 15:59:06 +02:00
|
|
|
DataManagementPlanCriteria dataManagementPlanCriteria = new DataManagementPlanCriteria();
|
|
|
|
dataManagementPlanCriteria.setAllVersions(false);
|
2020-07-03 09:43:19 +02:00
|
|
|
dataManagementPlanCriteria.setLike(tableRequest.getCriteria().getLike());
|
2020-07-24 11:12:54 +02:00
|
|
|
dataManagementPlanCriteria.setIsPublic(!isAuthenticated);
|
|
|
|
dataManagementPlanCriteria.setOnlyPublic(!isAuthenticated);
|
2020-06-30 15:59:06 +02:00
|
|
|
|
2022-02-21 16:16:32 +01:00
|
|
|
//GK: Use the managers to get the data in order to be better synced with other lists
|
|
|
|
DataManagementPlanTableRequest dataManagementPlanTableRequest = new DataManagementPlanTableRequest();
|
|
|
|
dataManagementPlanTableRequest.setCriteria(dataManagementPlanCriteria);
|
|
|
|
dataManagementPlanTableRequest.setOrderings(tableRequest.getOrderings());
|
|
|
|
dataManagementPlanTableRequest.setLength(tableRequest.getLength());
|
|
|
|
dataManagementPlanTableRequest.setOffset(tableRequest.getDmpOffset());
|
|
|
|
DataTableData<DataManagementPlanListingModel> dmps = this.dataManagementPlanManager.getPaged(dataManagementPlanTableRequest, principal, "listing");
|
|
|
|
recentActivityModels.addAll(dmps.getData().stream().map(dataManagementPlanListingModel -> new RecentDmpModel().fromDataModel(dataManagementPlanListingModel.toDataModel())).collect(Collectors.toList()));
|
|
|
|
DatasetTableRequest datasetTableRequest = new DatasetTableRequest();
|
|
|
|
datasetCriteria.setCollaborators(new ArrayList<>());
|
|
|
|
datasetTableRequest.setCriteria(datasetCriteria);
|
|
|
|
datasetTableRequest.setOrderings(tableRequest.getOrderings());
|
|
|
|
datasetTableRequest.getOrderings().getFields().addAll(datasetTableRequest.getOrderings().getFields().stream().filter(s -> s.contains("publishedAt")).map(s -> s.charAt(0) + "dmp:" + s.substring(1) + "|join|").collect(Collectors.toList()));
|
|
|
|
datasetTableRequest.getOrderings().getFields().removeIf(s -> s.contains("publishedAt") && !s.endsWith("|join|"));
|
|
|
|
datasetTableRequest.setLength(tableRequest.getLength());
|
|
|
|
datasetTableRequest.setOffset(tableRequest.getDatasetOffset());
|
|
|
|
DataTableData<DatasetListingModel> datasets = this.datasetManager.getPaged(datasetTableRequest, principal);
|
|
|
|
recentActivityModels.addAll(datasets.getData().stream().map(datasetListingModel -> new RecentDatasetModel().fromDataModel(datasetListingModel.toDataModel())).collect(Collectors.toList()));
|
2020-07-03 12:55:25 +02:00
|
|
|
|
2020-07-27 17:16:32 +02:00
|
|
|
//GK: Shuffle the deck otherwise we will summon the DMPodia when sorting with status
|
2021-10-12 14:41:20 +02:00
|
|
|
/*int pos = -1;
|
2020-07-27 17:16:32 +02:00
|
|
|
for (int i = (recentActivityModels.size() / 2); i < recentActivityModels.size(); i++) {
|
|
|
|
RecentActivityModel recentActivityModel = recentActivityModels.remove(i);
|
|
|
|
while (pos < recentActivityModels.size()) {
|
|
|
|
pos++;
|
|
|
|
if (pos % 2 != 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
recentActivityModels.add(pos, recentActivityModel);
|
2021-10-12 14:41:20 +02:00
|
|
|
}*/
|
|
|
|
//GK: No one likes to play shuffle with the recent activities. So just re-sort them based on how they have been sorted already
|
|
|
|
|
2022-02-21 16:16:32 +01:00
|
|
|
String order = tableRequest.getOrderings().getFields().get(0).toCharArray()[0] + "";
|
|
|
|
String field = tableRequest.getOrderings().getFields().get(0).substring(1);
|
|
|
|
if (field.contains(":") && field.contains("|")) {
|
|
|
|
field = field.substring(field.lastIndexOf(":") + 1, field.indexOf("|"));
|
|
|
|
}
|
|
|
|
field = field.equals("label") ? "title" : field;
|
|
|
|
field = field.substring(0, 1).toUpperCase() + field.substring(1);
|
|
|
|
String finalField = field;
|
2021-10-12 14:41:20 +02:00
|
|
|
recentActivityModels = recentActivityModels.stream().sorted((o1, o2) -> {
|
|
|
|
try {
|
2022-02-21 16:16:32 +01:00
|
|
|
return (order.equals("+") ? 1 : -1 ) * ((Comparable)o1.getClass().getMethod("get" + finalField).invoke(o1)).compareTo(o2.getClass().getMethod("get" + finalField).invoke(o2));
|
2021-10-12 14:41:20 +02:00
|
|
|
} catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
|
|
|
|
logger.error(e.getLocalizedMessage(), e);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}).collect(Collectors.toList());
|
2020-07-03 12:55:25 +02:00
|
|
|
|
2021-08-04 17:38:49 +02:00
|
|
|
return recentActivityModels;
|
2020-06-30 15:59:06 +02:00
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public List<SearchBarItem> searchUserData(String like, Principal principal) {
|
2018-08-24 17:21:02 +02:00
|
|
|
UserInfo user = new UserInfo();
|
|
|
|
user.setId(principal.getId());
|
2019-03-05 16:33:59 +01:00
|
|
|
DMPDao dataManagementPlanRepository = databaseRepository.getDmpDao();
|
|
|
|
DatasetDao datasetRepository = databaseRepository.getDatasetDao();
|
2019-07-31 16:57:34 +02:00
|
|
|
GrantDao grantRepository = databaseRepository.getGrantDao();
|
2018-08-24 17:21:02 +02:00
|
|
|
|
2019-09-26 11:44:39 +02:00
|
|
|
List<Integer> roles = new LinkedList<>();
|
2018-08-24 17:21:02 +02:00
|
|
|
List<SearchBarItem> searchBarItems = new LinkedList<>();
|
2020-01-03 15:52:27 +01:00
|
|
|
|
|
|
|
CompletableFuture<List<SearchBarItem>> publicDmps = dataManagementPlanRepository.asQueryable()
|
2018-09-18 14:41:24 +02:00
|
|
|
.where((builder, root) -> builder.like(builder.upper(root.get("label")), "%" + like.toUpperCase() + "%"))
|
2019-12-16 11:18:49 +01:00
|
|
|
.where((builder, root) -> builder.notEqual(root.get("status"), DMP.DMPStatus.DELETED.getValue()))
|
2020-01-03 15:52:27 +01:00
|
|
|
.where((builder, root) -> builder.equal(root.get("isPublic"), true))
|
2018-08-24 17:21:02 +02:00
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
2020-01-03 15:52:27 +01:00
|
|
|
.selectAsync(item -> new SearchBarItem(item.getId().toString(), item.getLabel(), SearchBarItemType.DMP.getValue(), true))
|
2018-08-24 17:21:02 +02:00
|
|
|
.whenComplete((dmpItems, throwable) -> searchBarItems.addAll(dmpItems));
|
|
|
|
|
2020-01-03 15:52:27 +01:00
|
|
|
CompletableFuture<List<SearchBarItem>> publicDatasets = datasetRepository.asQueryable()
|
2018-09-18 14:41:24 +02:00
|
|
|
.where((builder, root) -> builder.like(builder.upper(root.get("label")), "%" + like.toUpperCase() + "%"))
|
2020-01-03 15:52:27 +01:00
|
|
|
.where((builder, root) -> builder.equal(root.get("status"), Dataset.Status.FINALISED.getValue()))
|
|
|
|
.where((builder, root) -> builder.equal(root.get("dmp").get("isPublic"), true))
|
2018-08-24 17:21:02 +02:00
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
2020-01-03 15:52:27 +01:00
|
|
|
.selectAsync(item -> new SearchBarItem(item.getId().toString(), item.getLabel(), SearchBarItemType.DATASET.getValue(), true))
|
2018-08-24 17:21:02 +02:00
|
|
|
.whenComplete((dataSetItems, throwable) -> searchBarItems.addAll(dataSetItems));
|
|
|
|
|
2020-01-03 15:52:27 +01:00
|
|
|
if (principal.getId() != null) {
|
|
|
|
CompletableFuture<List<SearchBarItem>> dmps = dataManagementPlanRepository.getAuthenticated(dataManagementPlanRepository.asQueryable(), principal.getId(), roles)
|
|
|
|
.withHint("dmpRecentActivity")
|
|
|
|
.where((builder, root) -> builder.like(builder.upper(root.get("label")), "%" + like.toUpperCase() + "%"))
|
|
|
|
.where((builder, root) -> builder.notEqual(root.get("status"), DMP.DMPStatus.DELETED.getValue()))
|
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.selectAsync(item -> new SearchBarItem(item.getId().toString(), item.getLabel(), SearchBarItemType.DMP.getValue(), false))
|
|
|
|
.whenComplete((dmpItems, throwable) -> searchBarItems.addAll(dmpItems));
|
|
|
|
|
|
|
|
CompletableFuture<List<SearchBarItem>> datasets = datasetRepository.getAuthenticated(datasetRepository.asQueryable(), user, roles)
|
|
|
|
.withHint("datasetRecentActivity")
|
|
|
|
.where((builder, root) -> builder.like(builder.upper(root.get("label")), "%" + like.toUpperCase() + "%"))
|
|
|
|
.where((builder, root) -> builder.notEqual(root.get("status"), Dataset.Status.DELETED.getValue()))
|
|
|
|
.where((builder, root) -> builder.notEqual(root.get("status"), Dataset.Status.CANCELED.getValue()))
|
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.selectAsync(item -> new SearchBarItem(item.getId().toString(), item.getLabel(), SearchBarItemType.DATASET.getValue(), false))
|
|
|
|
.whenComplete((dataSetItems, throwable) -> searchBarItems.addAll(dataSetItems));
|
|
|
|
|
|
|
|
CompletableFuture<List<SearchBarItem>> grants = grantRepository.getAuthenticated(grantRepository.asQueryable(), user)
|
|
|
|
.withHint("grantRecentActivity")
|
|
|
|
.where((builder, root) -> builder.like(builder.upper(root.get("label")), "%" + like.toUpperCase() + "%"))
|
|
|
|
.orderBy((builder, root) -> builder.desc(root.get("modified")))
|
|
|
|
.selectAsync(item -> new SearchBarItem(item.getId().toString(), item.getLabel(), SearchBarItemType.GRANT.getValue(), false))
|
|
|
|
.whenComplete((grantItems, throwable) -> searchBarItems.addAll(grantItems));
|
|
|
|
|
|
|
|
CompletableFuture.allOf(grants, dmps, datasets, publicDmps, publicDatasets).join();
|
|
|
|
} else {
|
|
|
|
CompletableFuture.allOf(publicDmps, publicDatasets).join();
|
|
|
|
}
|
2018-08-24 17:21:02 +02:00
|
|
|
|
|
|
|
return searchBarItems;
|
|
|
|
}
|
2017-12-14 18:07:09 +01:00
|
|
|
}
|