Exemplo n.º 1
0
  /** @return the standard terms as a {@link LanguageTexts} */
  public LanguageTexts getStandardTermsAsLanguageTexts() {
    Collection<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();

    if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
    LanguageTexts outTerms = new R01MStructureLabelTermsAsLanguageTextsView(standardTerms);
    return outTerms;
  }
 /**
  * Returns a map with the labels of a certain structure indexed by their oid
  *
  * @param cats
  * @param structureOid
  * @param role
  * @return
  */
 private static Map<String, String> _labelsInStructure(
     final List<R01MSearchResultItemStructureCatalog> cats,
     final String structureOid,
     final String role) {
   if (CollectionUtils.isNullOrEmpty(cats)) return null;
   Collection<R01MSearchResultItemStructureCatalog> roleCats =
       FluentIterable.from(cats)
           .filter(
               new Predicate<R01MSearchResultItemStructureCatalog>() {
                 @Override
                 public boolean apply(final R01MSearchResultItemStructureCatalog cat) {
                   return cat.getStructureOid().equals(structureOid) && cat.getRole().equals(role);
                 }
               })
           .toList();
   // Get the labels descriptions
   Map<String, String> outCats = new HashMap<String, String>(roleCats.size());
   Labels labels = LABELS.get(structureOid);
   for (R01MSearchResultItemStructureCatalog cat : roleCats) {
     String labelOid = cat.getLabelOid();
     String label = labels.getByOid(labelOid);
     if (label != null) outCats.put(labelOid, label);
   }
   return outCats;
 }
Exemplo n.º 3
0
  /////////////////////////////////////////////////////////////////////////////////////////
  //  JPQL
  /////////////////////////////////////////////////////////////////////////////////////////
  protected String _jpqlQueryFrom(final BooleanQueryClause qryClause) {
    if (qryClause == null || CollectionUtils.isNullOrEmpty(qryClause.getClauses())) {
      log.warn("A filter with NO filter parameters was received... al records will be returned");
      return null;
    }

    String dbFieldId = qryClause.getFieldId().asString();

    StringBuilder outJPQL = new StringBuilder();
    outJPQL.append("(");

    Set<QualifiedQueryClause<? extends QueryClause>> clauses = qryClause.getClauses();

    QueryClauseOccur prevClauseOccur = null;
    for (Iterator<QualifiedQueryClause<? extends QueryClause>> clauseIt = clauses.iterator();
        clauseIt.hasNext(); ) {
      QualifiedQueryClause<? extends QueryClause> clause = clauseIt.next();

      String jpqlQuery = _jpqlQueryFrom(clause.getClause());
      String jpqlJoin = _jpqlJoinFor(clause.getOccur());

      if (jpqlQuery != null) {
        if (prevClauseOccur != null) outJPQL.append(jpqlJoin);
        if (clauseIt.hasNext()) prevClauseOccur = clause.getOccur();

        outJPQL.append("(");
        outJPQL.append(jpqlQuery); // The clause
        outJPQL.append(")");
      } else {
        log.error("A null lucene query was returned for field {}", dbFieldId);
      }
    }
    outJPQL.append(")");
    return outJPQL.toString();
  }
Exemplo n.º 4
0
  /**
   * Sets the synonymous terms by language
   *
   * @param theSynonymousTerms The synonimousTerms to set.
   */
  public void addSynonymousTerms(final Collection<R01MStructureLabelTerm> theSynonymousTerms) {
    if (CollectionUtils.isNullOrEmpty(theSynonymousTerms)) return;
    if (_terms == null) _terms = new HashSet<R01MStructureLabelTerm>();

    // Ensure that the provided term is NOT a synonymous term and add it to the list
    for (R01MStructureLabelTerm term : theSynonymousTerms) {
      term.setType(R01MStructureLabelTermType.SYNONIMOUS);
      _terms.add(term);
    }
  }
Exemplo n.º 5
0
 /**
  * Gets the standard descriptions
  *
  * @return
  */
 public Set<R01MStructureLabelTerm> getStandardTerms() {
   if (CollectionUtils.isNullOrEmpty(_terms)) return null;
   return FluentIterable.from(_terms)
       .filter(
           new Predicate<R01MStructureLabelTerm>() {
             @Override
             public boolean apply(final R01MStructureLabelTerm term) {
               return term.isStandarized();
             }
           })
       .toSet();
 }
Exemplo n.º 6
0
 /**
  * The label terms in a language
  *
  * @param lang
  * @return
  */
 public Set<R01MStructureLabelTerm> getTermsIn(final Language lang) {
   if (CollectionUtils.isNullOrEmpty(_terms)) return null;
   return FluentIterable.from(_terms)
       .filter(
           new Predicate<R01MStructureLabelTerm>() {
             @Override
             public boolean apply(final R01MStructureLabelTerm term) {
               return term.getLang() == lang;
             }
           })
       .toSet();
 }
Exemplo n.º 7
0
  /**
   * Gets the standard term in a language
   *
   * @param
   * @return
   */
  public R01MStructureLabelTerm getStandardTermIn(final Language lang) {
    Set<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();

    if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
    R01MStructureLabelTerm outTerm = null;
    for (R01MStructureLabelTerm term : standardTerms) {
      if (term.isStandarized() && term.getLang() == lang) {
        outTerm = term;
        break;
      }
    }
    return outTerm;
  }
 /**
  * @return the found entities' oids if the persistence find operation was successful or a
  *     PersistenteException if not
  * @throws PersistenceException
  */
 public <O extends OID> Collection<O> getOidsOrThrow() throws PersistenceException {
   if (CollectionUtils.isNullOrEmpty(_operationExecResult)) return Lists.newArrayList();
   return FluentIterable.from(_operationExecResult)
       .transform(
           new Function<M, O>() {
             @Override
             @SuppressWarnings("unchecked")
             public O apply(final M entity) {
               return (O) entity.getOid();
             }
           })
       .toList();
 }
Exemplo n.º 9
0
  /** @return the standard terms defined languages */
  public Set<Language> getStandardTermsLanguages() {
    Set<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();

    if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
    return FluentIterable.from(standardTerms)
        .transform(
            new Function<R01MStructureLabelTerm, Language>() {
              @Override
              public Language apply(final R01MStructureLabelTerm term) {
                return term.getLang();
              }
            })
        .toSet();
  }
Exemplo n.º 10
0
  /**
   * Gets the synonymous terms in a language
   *
   * @param lang
   * @return
   */
  public Set<String> getSynonimousTermsTextIn(final Language lang) {
    if (CollectionUtils.isNullOrEmpty(_terms)) return null;

    return FluentIterable.from(_terms)
        .filter(
            new Predicate<R01MStructureLabelTerm>() {
              @Override
              public boolean apply(final R01MStructureLabelTerm term) {
                return term.isSynomimous() && term.getLang().is(lang);
              }
            })
        .transform(
            new Function<R01MStructureLabelTerm, String>() {
              @Override
              public String apply(final R01MStructureLabelTerm term) {
                return term.getValue();
              }
            })
        .toSet();
  }
Exemplo n.º 11
0
 /**
  * Adds a synonymous term in a language
  *
  * @param theSynonimousTerm
  */
 public void addSynonymousTerms(final R01MStructureLabelTerm... theSynonymousTerms) {
   if (CollectionUtils.isNullOrEmpty(theSynonymousTerms)) return;
   Collection<R01MStructureLabelTerm> terms = CollectionUtils.of(theSynonymousTerms).asSet();
   this.addSynonymousTerms(terms);
 }
  /**
   * Captures java generics to do the service interface to implementation / proxy bindings
   *
   * @param binder
   * @param apiDef
   */
  @SuppressWarnings({"unchecked"})
  private static <S extends ServiceInterface> Class<S> _bindServiceInterfaceToImplOrProxy(
      final Binder binder, final ServiceToImplAndProxyDef<S> serviceToImplDef) {
    Class<S> serviceImplOrProxyType = null;

    log.warn("\t\t> {} ", serviceToImplDef.debugInfo());

    // [1] - The bean impl ia available... NO proxy is needed
    if (serviceToImplDef.getBeanServiceImplType() != null) {

      log.warn(
          "\t\t\t>Bind {} to the BEAN IMPLEMENTATION: {} (no proxy needed)",
          serviceToImplDef.getInterfaceType(),
          serviceToImplDef.getBeanServiceImplType());

      // The implementation is available:  Bind the service implementation to the interface
      // 									 annotated with @ServicesCoreImplementation
      serviceImplOrProxyType = (Class<S>) serviceToImplDef.getBeanServiceImplType();

      binder
          .bind(serviceToImplDef.getBeanServiceImplType())
          .in(Singleton.class); // the service impl as singleton
      binder
          .bind(serviceToImplDef.getInterfaceType())
          .to(serviceImplOrProxyType); // not annotated binding			
    }
    // [2] The bean implementation is NOT available: use the configured (REST, EJB...) proxy impl
    else {
      // bind the service interface default proxy or any other if the default one is NOT present
      ServicesImpl defaultServiceImpl = serviceToImplDef.getConfiguredDefaultProxyImpl();

      if (serviceToImplDef.getServiceProxyImplTypeOrNullFor(defaultServiceImpl) != null) {
        // the configured default proxy was found (the normal case)
        serviceImplOrProxyType =
            (Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(defaultServiceImpl);
        binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
        log.warn(
            "\t\t\t>Bind {} to the DEFAULT PROXY: {}",
            serviceToImplDef.getInterfaceType(),
            serviceImplOrProxyType);

      } else if (serviceToImplDef.getServiceProxyImplTypeOrNullFor(ServicesImpl.REST) != null) {
        // the configured default proxy was not found BUT the REST impl proxy is available
        serviceImplOrProxyType =
            (Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(ServicesImpl.REST);
        binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
        log.warn(
            "\t\t\t>Bind {} to the DEFAULT PROXY: {} (the default={} was NOT found so used {} instead)",
            serviceToImplDef.getInterfaceType(),
            ServicesImpl.REST,
            defaultServiceImpl,
            serviceImplOrProxyType);

      } else if (CollectionUtils.hasData(serviceToImplDef.getProxyTypeByImpl())) {
        // The configured proxy was not found... try to get another
        ServicesImpl anyImpl =
            CollectionUtils.pickOneElement(serviceToImplDef.getProxyTypeByImpl().keySet());
        serviceImplOrProxyType = (Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(anyImpl);
        binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
        log.warn(
            "\t\t\t>Bind {} to the DEFAULT PROXY: {} (the default={} was NOT found so used {} instead)",
            serviceToImplDef.getInterfaceType(),
            anyImpl,
            defaultServiceImpl,
            serviceImplOrProxyType);
      }

      // c) bind the proxy to service impl to be used at
      // ServicesClientProxyLazyLoaderGuiceMethodInterceptor
      if (CollectionUtils.isNullOrEmpty(serviceToImplDef.getProxyTypeByImpl())) {
        log.error(
            "\t\t\t>NO proxy for {} was not found: Is there any proxy type implementing {} available in the classpath?",
            serviceToImplDef.getInterfaceType(),
            serviceToImplDef.getInterfaceType());
      }
    }
    return serviceImplOrProxyType;
  }