コード例 #1
0
 @Test
 public void testGetDefaultAssociativeRelationshipRoleStatus() {
   ThesaurusConcept concept1 = new ThesaurusConcept();
   concept1.setIdentifier("http://www.culturecommunication.gouv.fr/co1");
   List<String> associatedConcepts =
       associativeRelationshipDAO.getAssociatedConcepts(concept1, ConceptStatusEnum.DEPRECATED);
   Assert.assertEquals(1, associatedConcepts.size());
   ListAssert.assertContains(associatedConcepts, "http://www.culturecommunication.gouv.fr/co2");
 }
コード例 #2
0
  public Alignment buildAlignment(
      Statement stmt, AlignmentType alignmentType, ThesaurusConcept concept) {
    logger.debug("Building alignment " + stmt.getObject().toString());

    Alignment alignment = new Alignment();
    alignment.setIdentifier(generatorService.generate(Alignment.class));
    alignment.setAlignmentType(alignmentType);
    alignment.setAndRelation(false);
    alignment.setCreated(concept.getCreated());
    alignment.setModified(concept.getModified());
    alignment.setSourceConcept(concept);

    if (alignmentType.isResource()) {

      Set<AlignmentResource> targetResources = new HashSet<AlignmentResource>();
      AlignmentResource targetResource = new AlignmentResource();

      String externalTargetResource = stmt.getObject().toString();

      targetResource.setAlignment(alignment);
      targetResource.setExternalTargetResource(externalTargetResource);

      targetResources.add(targetResource);
      alignment.setTargetResources(targetResources);

    } else {

      Set<AlignmentConcept> targetConcepts = new HashSet<AlignmentConcept>();

      AlignmentConcept targetConcept = new AlignmentConcept();
      targetConcept.setAlignment(alignment);

      String targetConceptId = stmt.getObject().toString();
      ThesaurusConcept internalTargetConcept =
          thesaurusConceptService.getThesaurusConceptById(targetConceptId);
      if (internalTargetConcept != null) {
        targetConcept.setInternalTargetConcept(internalTargetConcept);
        alignment.setInternalTargetThesaurus(internalTargetConcept.getThesaurus());
      } else {
        // Check if the concept has an ark indentifier.

        Matcher arkMt = arkPt.matcher(targetConceptId);
        Matcher urlMt = urlPt.matcher(targetConceptId);

        if (arkMt.find()) {
          setExternalThesaurus(alignment, arkMt.group());
        } else if (urlMt.find()) {
          setExternalThesaurus(alignment, urlMt.group());
        }
        targetConcept.setExternalTargetConcept(targetConceptId);
      }

      targetConcepts.add(targetConcept);
      alignment.setTargetConcepts(targetConcepts);
    }
    return alignment;
  }
コード例 #3
0
 @Override
 public int getStatusByConceptId(String conceptId) {
   ThesaurusConcept thesaurusConcept = thesaurusConceptDAO.getById(conceptId);
   if (thesaurusConcept != null) {
     return thesaurusConcept.getStatus();
   } else {
     throw new BusinessException(
         "Concept with identifier " + conceptId + " does not exist", "concepts-does-not-exist");
   }
 }
コード例 #4
0
  private List<ThesaurusConcept> getRecursiveChildrenByConceptId(
      String conceptId, String originalParentId, List<ThesaurusConcept> allRecursiveChildren) {
    List<ThesaurusConcept> childrenConcepts =
        thesaurusConceptDAO.getChildrenConcepts(conceptId, 0, null);

    for (ThesaurusConcept concept : childrenConcepts) {
      if (concept.getIdentifier() != originalParentId) {
        if (!allRecursiveChildren.contains(concept)) {
          allRecursiveChildren.add(concept);
        }
        getRecursiveChildrenByConceptId(
            concept.getIdentifier(), originalParentId, allRecursiveChildren);
      }
    }
    return allRecursiveChildren;
  }
コード例 #5
0
 @Override
 public List<ThesaurusConcept> getAllRootChildren(ThesaurusConcept concept) {
   Criteria criteria = getCurrentSession().createCriteria(ThesaurusConcept.class, "tc");
   criteria
       .createCriteria("tc.rootConcepts", "rc")
       .add(Restrictions.eq("rc.identifier", concept.getIdentifier()));
   return criteria.list();
 }
コード例 #6
0
  @Transactional(readOnly = false)
  @Override
  public ThesaurusConcept destroyThesaurusConcept(ThesaurusConcept object) {
    if (object.getStatus() == ConceptStatusEnum.CANDIDATE.getStatus()
        || object.getStatus() == ConceptStatusEnum.REJECTED.getStatus()) {
      List<ThesaurusTerm> terms = thesaurusTermDAO.findTermsByConceptId(object.getIdentifier());
      for (ThesaurusTerm term : terms) {
        term.setConcept(null);
        thesaurusTermDAO.update(term);
      }

      List<ThesaurusConcept> childrenConcepts =
          getChildrenByConceptId(object.getIdentifier(), null);
      for (ThesaurusConcept childConcept : childrenConcepts) {
        childConcept.getParentConcepts().remove(object);
        thesaurusConceptDAO.update(childConcept);
      }

      List<ThesaurusConcept> rootChildrenConcepts = thesaurusConceptDAO.getAllRootChildren(object);
      for (ThesaurusConcept rootChild : rootChildrenConcepts) {
        rootChild.getRootConcepts().remove(object);
        thesaurusConceptDAO.update(rootChild);
      }

      List<ThesaurusArray> arrays =
          thesaurusArrayDAO.getConceptSuperOrdinateArrays(object.getIdentifier());
      for (ThesaurusArray array : arrays) {
        thesaurusArrayDAO.delete(array);
      }
      List<Alignment> alignments = alignmentDAO.findByTargetConceptId(object.getIdentifier());
      for (Alignment alignment : alignments) {
        if (alignment.getTargetConcepts().size() <= 1) {
          alignmentDAO.delete(alignment);
        }
      }

      return thesaurusConceptDAO.delete(object);
    } else {
      throw new BusinessException(
          "It's not possible to delete a concept with a status different from candidate or rejected",
          "delete-concept");
    }
  }
コード例 #7
0
  private List<ThesaurusConcept> getRecursiveParentByConceptId(
      ThesaurusConcept beginConcept, List<ThesaurusConcept> arrayOfParent) {

    Set<ThesaurusConcept> parentConcepts = beginConcept.getParentConcepts();
    if (parentConcepts.size() > 0) {
      ThesaurusConcept parent = parentConcepts.iterator().next();
      arrayOfParent.add(parent);
      getRecursiveParentByConceptId(parent, arrayOfParent);
    }
    return arrayOfParent;
  }
コード例 #8
0
 @Override
 public String getConceptTitleLanguage(ThesaurusConcept concept) {
   return getConceptPreferredTerm(concept.getIdentifier()).getLanguage().getPart1();
 }
コード例 #9
0
 @Override
 public String getConceptTitle(ThesaurusConcept concept) {
   return getConceptPreferredTerm(concept.getIdentifier()).getLexicalValue();
 }
コード例 #10
0
  private ThesaurusConcept saveAssociativeRelationship(
      ThesaurusConcept concept, List<AssociativeRelationship> associatedConcepts) {
    Set<AssociativeRelationship> relations = new HashSet<AssociativeRelationship>();
    if (concept.getAssociativeRelationshipLeft() == null) {
      concept.setAssociativeRelationshipLeft(new HashSet<AssociativeRelationship>());
    } else {
      for (AssociativeRelationship associativeRelationship :
          concept.getAssociativeRelationshipLeft()) {
        associativeRelationshipDAO.delete(associativeRelationship);
      }
    }
    concept.getAssociativeRelationshipLeft().clear();

    if (concept.getAssociativeRelationshipRight() == null) {
      concept.setAssociativeRelationshipRight(new HashSet<AssociativeRelationship>());
    } else {
      for (AssociativeRelationship associativeRelationship :
          concept.getAssociativeRelationshipRight()) {
        associativeRelationshipDAO.delete(associativeRelationship);
      }
    }
    concept.getAssociativeRelationshipRight().clear();

    for (AssociativeRelationship association : associatedConcepts) {
      logger.debug("Settings associated concept " + association);

      if (association.getIdentifier().getConcept1() == association.getIdentifier().getConcept2()) {
        throw new BusinessException(
            "It's not possible to make association to itself!", "association-to-itself-error");
      }

      ThesaurusConcept linkedThesaurusConcept = association.getConceptRight();
      if (linkedThesaurusConcept.getStatus() != ConceptStatusEnum.VALIDATED.getStatus()) {
        throw new BusinessException(
            "A concept must associate a validated concept", "concept-associate-validated-concept");
      }
      List<String> alreadyAssociatedConcepts =
          associativeRelationshipDAO.getAssociatedConcepts(linkedThesaurusConcept);
      if (!alreadyAssociatedConcepts.contains(concept.getIdentifier())) {
        relations.add(association);
        if (association.getRelationshipRole() == null) {
          association.setRelationshipRole(new AssociativeRelationshipRole());
        }
        if (StringUtils.isEmpty(association.getRelationshipRole().getCode())) {
          association
              .getRelationshipRole()
              .setCode(
                  associativeRelationshipRoleDAO.getDefaultAssociativeRelationshipRole().getCode());
        }
      }
      associativeRelationshipDAO.update(association);
    }
    concept.getAssociativeRelationshipLeft().addAll(relations);

    return concept;
  }
コード例 #11
0
  @Transactional(readOnly = false)
  @Override
  public ThesaurusConcept updateThesaurusConcept(
      ThesaurusConcept object,
      List<ThesaurusTerm> terms,
      List<AssociativeRelationship> associatedConcepts,
      List<ConceptHierarchicalRelationship> hierarchicalRelationships,
      List<ThesaurusConcept> childrenConceptToDetach,
      List<ThesaurusConcept> childrenConceptToAttach,
      List<Alignment> alignments) {

    thesaurusTermUtils.checkTerms(terms);
    alignmentService.saveExternalThesauruses(alignments);

    if (StringUtils.isNotEmpty(object.getIdentifier())) {
      List<ThesaurusTerm> existingTerms =
          thesaurusTermDAO.findTermsByConceptId(object.getIdentifier());
      for (ThesaurusTerm existingTerm : existingTerms) {
        if (!terms.contains(existingTerm)) {
          ThesaurusTerm term = thesaurusTermDAO.getById(existingTerm.getIdentifier());
          term.setConcept(null);
          thesaurusTermDAO.update(term);
          logger.info("Marking Term with ID " + existingTerm.getIdentifier() + " as SandBoxed.");
        }
      }
    } else {
      object.setIdentifier(generatorService.generate(ThesaurusConcept.class));
      for (ConceptHierarchicalRelationship hierarchicalRelationship : hierarchicalRelationships) {
        hierarchicalRelationship.getIdentifier().setChildconceptid(object.getIdentifier());
      }
      for (AssociativeRelationship relation : associatedConcepts) {
        relation.getIdentifier().setConcept1(object.getIdentifier());
      }
    }
    List<ThesaurusConcept> allRecursiveChild =
        getRecursiveChildrenByConceptId(object.getIdentifier());
    List<ThesaurusConcept> allRecursiveParents =
        getRecursiveParentsByConceptId(object.getIdentifier());

    object =
        conceptHierarchicalRelationshipServiceUtil.saveHierarchicalRelationship(
            object,
            hierarchicalRelationships,
            allRecursiveParents,
            allRecursiveChild,
            childrenConceptToDetach,
            childrenConceptToAttach);

    if (object.getStatus() == ConceptStatusEnum.CANDIDATE.getStatus()) {
      // We can set status = candidate only if concept has not relation
      // (both hierarchical or associative)
      if (!associatedConcepts.isEmpty()
          || !object.getParentConcepts().isEmpty()
          || hasChildren(object.getIdentifier())) {
        throw new BusinessException(
            "A concept must not have a status candidate when it still have relations",
            "concept-status-candidate-relation");
      }
    }

    if (object.getStatus() == ConceptStatusEnum.VALIDATED.getStatus()) {
      // Test if parent concepts are validated
      Set<ThesaurusConcept> parents = object.getParentConcepts();
      for (ThesaurusConcept parent : parents) {
        if (parent.getStatus() != ConceptStatusEnum.VALIDATED.getStatus()) {
          throw new BusinessException(
              "A concept cannot have a parent which status is not validated",
              "concept-parent-not-validated");
        }
      }
    }

    ThesaurusConcept concept = thesaurusConceptDAO.update(object);
    updateConceptTerms(concept, terms);

    alignmentService.saveAlignments(concept, alignments);
    if (!alignments.isEmpty()) {
      alignmentService.deleteExternalThesauruses();
    }
    return thesaurusConceptDAO.update(saveAssociativeRelationship(concept, associatedConcepts));
  }