Examples with Relationships org.hisp.dhis.dxf2.events.trackedentity.Relationships used on opensource projects

Example 6 with Relationships

use of org.hisp.dhis.dxf2.events.trackedentity.Relationships in project dhis2-core by dhis2.

the class TrackedEntityInstanceAggregate method find.

/**
 * Fetches a List of {@see TrackedEntityInstance} based on the list of
 * primary keys and search parameters
 *
 * @param ids a List of {@see TrackedEntityInstance} Primary Keys
 * @param params an instance of {@see TrackedEntityInstanceParams}
 *
 * @return a List of {@see TrackedEntityInstance} objects
 */
public List<TrackedEntityInstance> find(List<Long> ids, TrackedEntityInstanceParams params, TrackedEntityInstanceQueryParams queryParams) {
    final User user = currentUserService.getCurrentUser();
    if (!userGroupUIDCache.get(user.getUid()).isPresent() && !CollectionUtils.isEmpty(user.getGroups())) {
        userGroupUIDCache.put(user.getUid(), user.getGroups().stream().map(group -> group.getUid()).collect(Collectors.toList()));
    }
    /*
         * Create a context with information which will be used to fetch the
         * entities
         */
    AggregateContext ctx = securityCache.get(user.getUid(), userUID -> getSecurityContext(userUID, userGroupUIDCache.get(userUID).orElse(Lists.newArrayList()))).toBuilder().userId(user.getId()).superUser(user.isSuper()).params(params).queryParams(queryParams).build();
    /*
         * Async fetch Relationships for the given TrackedEntityInstance id
         * (only if isIncludeRelationships = true)
         */
    final CompletableFuture<Multimap<String, Relationship>> relationshipsAsync = conditionalAsyncFetch(ctx.getParams().isIncludeRelationships(), () -> trackedEntityInstanceStore.getRelationships(ids), getPool());
    /*
         * Async fetch Enrollments for the given TrackedEntityInstance id (only
         * if isIncludeEnrollments = true)
         */
    final CompletableFuture<Multimap<String, Enrollment>> enrollmentsAsync = conditionalAsyncFetch(ctx.getParams().isIncludeEnrollments(), () -> enrollmentAggregate.findByTrackedEntityInstanceIds(ids, ctx), getPool());
    /*
         * Async fetch all ProgramOwner for the given TrackedEntityInstance id
         */
    final CompletableFuture<Multimap<String, ProgramOwner>> programOwnersAsync = conditionalAsyncFetch(ctx.getParams().isIncludeProgramOwners(), () -> trackedEntityInstanceStore.getProgramOwners(ids), getPool());
    /*
         * Async Fetch TrackedEntityInstances by id
         */
    final CompletableFuture<Map<String, TrackedEntityInstance>> teisAsync = supplyAsync(() -> trackedEntityInstanceStore.getTrackedEntityInstances(ids, ctx), getPool());
    /*
         * Async fetch TrackedEntityInstance Attributes by TrackedEntityInstance
         * id
         */
    final CompletableFuture<Multimap<String, Attribute>> attributesAsync = supplyAsync(() -> trackedEntityInstanceStore.getAttributes(ids), getPool());
    /*
         * Async fetch Owned Tei mapped to the provided program attributes by
         * TrackedEntityInstance id
         */
    final CompletableFuture<Multimap<String, String>> ownedTeiAsync = supplyAsync(() -> trackedEntityInstanceStore.getOwnedTeis(ids, ctx), getPool());
    /*
         * Execute all queries and merge the results
         */
    return allOf(teisAsync, attributesAsync, relationshipsAsync, enrollmentsAsync, ownedTeiAsync).thenApplyAsync(fn -> {
        Map<String, TrackedEntityInstance> teis = teisAsync.join();
        Multimap<String, Attribute> attributes = attributesAsync.join();
        Multimap<String, Relationship> relationships = relationshipsAsync.join();
        Multimap<String, Enrollment> enrollments = enrollmentsAsync.join();
        Multimap<String, ProgramOwner> programOwners = programOwnersAsync.join();
        Multimap<String, String> ownedTeis = ownedTeiAsync.join();
        Stream<String> teiUidStream = teis.keySet().parallelStream();
        if (queryParams.hasProgram()) {
            teiUidStream = teiUidStream.filter(ownedTeis::containsKey);
        }
        return teiUidStream.map(uid -> {
            TrackedEntityInstance tei = teis.get(uid);
            tei.setAttributes(filterAttributes(attributes.get(uid), ownedTeis.get(uid), teiAttributesCache.get("ALL_ATTRIBUTES", s -> trackedEntityAttributeService.getTrackedEntityAttributesByTrackedEntityTypes()), programTeiAttributesCache.get("ATTRIBUTES_BY_PROGRAM", s -> trackedEntityAttributeService.getTrackedEntityAttributesByProgram()), ctx));
            tei.setRelationships(new ArrayList<>(relationships.get(uid)));
            tei.setEnrollments(filterEnrollments(enrollments.get(uid), ownedTeis.get(uid), ctx));
            tei.setProgramOwners(new ArrayList<>(programOwners.get(uid)));
            return tei;
        }).collect(Collectors.toList());
    }, getPool()).join();
}

Example 7 with Relationships

use of org.hisp.dhis.dxf2.events.trackedentity.Relationships in project dhis2-core by dhis2.

the class AbstractTrackedEntityInstanceService method mergeOrDeleteTrackedEntityInstances.

// -------------------------------------------------------------------------
// CREATE, UPDATE or DELETE
// -------------------------------------------------------------------------
@Override
@Transactional
public ImportSummaries mergeOrDeleteTrackedEntityInstances(List<TrackedEntityInstance> trackedEntityInstances, ImportOptions importOptions, JobConfiguration jobId) {
    notifier.clear(jobId).notify(jobId, "Importing tracked entities");
    try {
        ImportSummaries importSummaries = new ImportSummaries();
        importOptions = updateImportOptions(importOptions);
        List<TrackedEntityInstance> create = new ArrayList<>();
        List<TrackedEntityInstance> update = new ArrayList<>();
        List<TrackedEntityInstance> delete = new ArrayList<>();
        // TODO: Check whether relationships are modified during
        // create/update/delete TEI logic. Decide whether logic below can be
        // removed
        List<Relationship> relationships = getRelationships(trackedEntityInstances);
        setTrackedEntityListByStrategy(trackedEntityInstances, importOptions, create, update, delete);
        importSummaries.addImportSummaries(addTrackedEntityInstances(create, importOptions));
        importSummaries.addImportSummaries(updateTrackedEntityInstances(update, importOptions));
        importSummaries.addImportSummaries(deleteTrackedEntityInstances(delete, importOptions));
        // TODO: Created importSummaries don't contain correct href (TEI
        // endpoint instead of relationships is used)
        importSummaries.addImportSummaries(relationshipService.processRelationshipList(relationships, importOptions));
        if (ImportReportMode.ERRORS == importOptions.getReportMode()) {
            importSummaries.getImportSummaries().removeIf(is -> !is.hasConflicts());
        }
        notifier.notify(jobId, NotificationLevel.INFO, "Import done", true).addJobSummary(jobId, importSummaries, ImportSummaries.class);
        return importSummaries;
    } catch (RuntimeException ex) {
        log.error(DebugUtils.getStackTrace(ex));
        notifier.notify(jobId, ERROR, "Process failed: " + ex.getMessage(), true);
        return new ImportSummaries().addImportSummary(new ImportSummary(ImportStatus.ERROR, "The import process failed: " + ex.getMessage()));
    }
}

Example 8 with Relationships

use of org.hisp.dhis.dxf2.events.trackedentity.Relationships in project dhis2-core by dhis2.

the class AbstractRelationshipService method prepareCaches.

private void prepareCaches(List<Relationship> relationships, User user) {
    Map<RelationshipEntity, List<String>> relationshipEntities = new HashMap<>();
    Map<String, List<Relationship>> relationshipTypeMap = relationships.stream().collect(Collectors.groupingBy(Relationship::getRelationshipType));
    // Find all the RelationshipTypes first, so we know what the uids refer
    // to
    Query query = Query.from(schemaService.getDynamicSchema(RelationshipType.class));
    query.setUser(user);
    query.add(Restrictions.in("id", relationshipTypeMap.keySet()));
    queryService.query(query).forEach(rt -> relationshipTypeCache.put(rt.getUid(), (RelationshipType) rt));
    // Group all uids into their respective RelationshipEntities
    relationshipTypeCache.values().forEach(relationshipType -> {
        List<String> fromUids = relationshipTypeMap.get(relationshipType.getUid()).stream().map((r) -> getUidOfRelationshipItem(r.getFrom())).collect(Collectors.toList());
        List<String> toUids = relationshipTypeMap.get(relationshipType.getUid()).stream().map((r) -> getUidOfRelationshipItem(r.getTo())).collect(Collectors.toList());
        // Merge existing results with newly found ones.
        relationshipEntities.merge(relationshipType.getFromConstraint().getRelationshipEntity(), fromUids, (old, _new) -> ListUtils.union(old, _new));
        relationshipEntities.merge(relationshipType.getToConstraint().getRelationshipEntity(), toUids, (old, _new) -> ListUtils.union(old, _new));
    });
    // Find and put all Relationship members in their respective cache
    if (relationshipEntities.get(TRACKED_ENTITY_INSTANCE) != null) {
        teiDaoService.getTrackedEntityInstancesByUid(relationshipEntities.get(TRACKED_ENTITY_INSTANCE), user).forEach(tei -> trackedEntityInstanceCache.put(tei.getUid(), tei));
    }
    if (relationshipEntities.get(PROGRAM_INSTANCE) != null) {
        Query piQuery = Query.from(schemaService.getDynamicSchema(ProgramInstance.class));
        piQuery.setUser(user);
        piQuery.add(Restrictions.in("id", relationshipEntities.get(PROGRAM_INSTANCE)));
        queryService.query(piQuery).forEach(pi -> programInstanceCache.put(pi.getUid(), (ProgramInstance) pi));
    }
    if (relationshipEntities.get(PROGRAM_STAGE_INSTANCE) != null) {
        Query psiQuery = Query.from(schemaService.getDynamicSchema(ProgramStageInstance.class));
        psiQuery.setUser(user);
        psiQuery.add(Restrictions.in("id", relationshipEntities.get(PROGRAM_STAGE_INSTANCE)));
        queryService.query(psiQuery).forEach(psi -> programStageInstanceCache.put(psi.getUid(), (ProgramStageInstance) psi));
    }
}

Example 9 with Relationships

use of org.hisp.dhis.dxf2.events.trackedentity.Relationships in project dhis2-core by dhis2.

the class AbstractRelationshipService method addRelationships.

@Override
@Transactional
public ImportSummaries addRelationships(List<Relationship> relationships, ImportOptions importOptions) {
    List<List<Relationship>> partitions = Lists.partition(relationships, FLUSH_FREQUENCY);
    importOptions = updateImportOptions(importOptions);
    ImportSummaries importSummaries = new ImportSummaries();
    for (List<Relationship> _relationships : partitions) {
        reloadUser(importOptions);
        prepareCaches(_relationships, importOptions.getUser());
        for (Relationship relationship : _relationships) {
            importSummaries.addImportSummary(addRelationship(relationship, importOptions));
        }
        clearSession();
    }
    return importSummaries;
}

Example 10 with Relationships

use of org.hisp.dhis.dxf2.events.trackedentity.Relationships in project dhis2-core by dhis2.

the class AbstractRelationshipService method deleteRelationships.

@Override
@Transactional
public ImportSummaries deleteRelationships(List<Relationship> relationships, ImportOptions importOptions) {
    ImportSummaries importSummaries = new ImportSummaries();
    importOptions = updateImportOptions(importOptions);
    int counter = 0;
    for (Relationship relationship : relationships) {
        importSummaries.addImportSummary(deleteRelationship(relationship.getRelationship(), importOptions));
        if (counter % FLUSH_FREQUENCY == 0) {
            clearSession();
        }
        counter++;
    }
    return importSummaries;
}