private EntityMapping toEntityMapping(Entity entityMappingEntity) {
    String identifier = entityMappingEntity.getString(EntityMappingMetaData.IDENTIFIER);

    EntityType targetEntityType;
    try {
      targetEntityType =
          dataService.getEntityType(
              entityMappingEntity.getString(EntityMappingMetaData.TARGET_ENTITY_TYPE));
    } catch (UnknownEntityException uee) {
      LOG.error(uee.getMessage());
      targetEntityType = null;
    }

    EntityType sourceEntityType;
    try {
      sourceEntityType =
          dataService.getEntityType(
              entityMappingEntity.getString(EntityMappingMetaData.SOURCE_ENTITY_TYPE));
    } catch (UnknownEntityException uee) {
      LOG.error(uee.getMessage());
      sourceEntityType = null;
    }

    List<Entity> attributeMappingEntities =
        Lists.<Entity>newArrayList(
            entityMappingEntity.getEntities(EntityMappingMetaData.ATTRIBUTE_MAPPINGS));
    List<AttributeMapping> attributeMappings =
        attributeMappingRepository.getAttributeMappings(
            attributeMappingEntities, sourceEntityType, targetEntityType);

    return new EntityMapping(identifier, sourceEntityType, targetEntityType, attributeMappings);
  }
 @Override
 public <E extends Entity> Iterable<E> getEntities(String attributeName, Class<E> clazz) {
   if (fetch.hasField(attributeName)) {
     return decoratedEntity.getEntities(attributeName, clazz);
   } else {
     return entityManager
         .getReference(getEntityMetaData(), getIdValue())
         .getEntities(attributeName, clazz);
   }
 }
 @Override
 public Iterable<Entity> getEntities(String attributeName) {
   if (fetch.hasField(attributeName)) {
     return decoratedEntity.getEntities(attributeName);
   } else {
     return entityManager
         .getReference(getEntityMetaData(), getIdValue())
         .getEntities(attributeName);
   }
 }
Exemple #4
0
  @Test
  public void checkMrefValidWrongType() {
    AttributeMetaData refIdAttr =
        when(mock(AttributeMetaData.class).getName()).thenReturn("refId").getMock();
    when(refIdAttr.getDataType()).thenReturn(STRING);

    EntityMetaData refEntityMeta = mock(EntityMetaData.class);
    when(refEntityMeta.getName()).thenReturn("refEntity");
    when(refEntityMeta.getIdAttribute()).thenReturn(refIdAttr);
    when(refEntityMeta.getAtomicAttributes()).thenReturn(asList(refIdAttr));

    String idAttrName = "id";
    String mrefAttrName = "mref";
    AttributeMetaData idAttr =
        when(mock(AttributeMetaData.class).getName()).thenReturn(idAttrName).getMock();
    when(idAttr.getDataType()).thenReturn(STRING);
    AttributeMetaData mrefAttr =
        when(mock(AttributeMetaData.class).getName()).thenReturn(mrefAttrName).getMock();
    when(mrefAttr.getDataType()).thenReturn(MREF);
    when(mrefAttr.getRefEntity()).thenReturn(refEntityMeta);

    EntityMetaData entityMeta = mock(EntityMetaData.class);
    when(entityMeta.getName()).thenReturn("entity");
    when(entityMeta.getIdAttribute()).thenReturn(idAttr);
    when(entityMeta.getAtomicAttributes()).thenReturn(asList(idAttr, mrefAttr));

    AttributeMetaData otherRefIdAttr =
        when(mock(AttributeMetaData.class).getName()).thenReturn("otherRefId").getMock();
    when(otherRefIdAttr.getDataType()).thenReturn(STRING);

    EntityMetaData otherRefEntityMeta = mock(EntityMetaData.class);
    when(otherRefEntityMeta.getName()).thenReturn("otherRefEntity");
    when(otherRefEntityMeta.getIdAttribute()).thenReturn(refIdAttr);
    when(otherRefEntityMeta.getAtomicAttributes()).thenReturn(asList(otherRefIdAttr));

    Entity refEntity0 =
        when(mock(Entity.class).getEntityMetaData()).thenReturn(otherRefEntityMeta).getMock();
    when(refEntity0.getIdValue()).thenReturn("refId0");

    Entity refEntity1 =
        when(mock(Entity.class).getEntityMetaData()).thenReturn(otherRefEntityMeta).getMock();
    when(refEntity1.getIdValue()).thenReturn("refId1");

    Entity entity0 = when(mock(Entity.class).getEntityMetaData()).thenReturn(entityMeta).getMock();
    when(entity0.getIdValue()).thenReturn("id0");
    when(entity0.getEntities(mrefAttrName)).thenReturn(asList(refEntity0, refEntity1));

    Set<ConstraintViolation> constraints =
        entityAttributesValidator.validate(entity0, entity0.getEntityMetaData());
    assertEquals(constraints.size(), 1);
  }
  /**
   * A helper function that gets identifiers of all the attributes from one entityMetaData
   *
   * @param sourceEntityMetaData
   * @return
   */
  public List<String> getAttributeIdentifiers(EntityMetaData sourceEntityMetaData) {
    Entity entityMetaDataEntity =
        dataService.findOne(
            EntityMetaDataMetaData.ENTITY_NAME,
            new QueryImpl().eq(EntityMetaDataMetaData.FULL_NAME, sourceEntityMetaData.getName()));

    if (entityMetaDataEntity == null)
      throw new MolgenisDataAccessException(
          "Could not find EntityMetaDataEntity by the name of " + sourceEntityMetaData.getName());

    return FluentIterable.from(entityMetaDataEntity.getEntities(EntityMetaDataMetaData.ATTRIBUTES))
        .transform(
            new Function<Entity, String>() {
              public String apply(Entity attributeEntity) {
                return attributeEntity.getString(AttributeMetaDataMetaData.IDENTIFIER);
              }
            })
        .toList();
  }
  private void validateEntityValueReferences(Entity entity, ValidationResource validationResource) {
    validationResource
        .getRefAttrs()
        .forEach(
            refAttr -> {
              HugeSet<Object> refEntityIds =
                  validationResource.getRefEntitiesIds().get(refAttr.getRefEntity().getName());

              Iterable<Entity> refEntities;
              if (refAttr.getDataType() instanceof XrefField) {
                Entity refEntity = entity.getEntity(refAttr.getName());
                if (refEntity != null) {
                  refEntities = singleton(refEntity);
                } else {
                  refEntities = emptyList();
                }
              } else {
                refEntities = entity.getEntities(refAttr.getName());
              }

              for (Entity refEntity : refEntities) {
                if (!refEntityIds.contains(refEntity.getIdValue())) {
                  boolean selfReference =
                      entity.getEntityMetaData().getName().equals(refAttr.getRefEntity().getName());
                  if (!(selfReference && entity.getIdValue().equals(refEntity.getIdValue()))) {
                    String message =
                        String.format(
                            "Unknown xref value '%s' for attribute '%s' of entity '%s'.",
                            DataConverter.toString(refEntity.getIdValue()),
                            refAttr.getName(),
                            getName());

                    ConstraintViolation constraintViolation =
                        new ConstraintViolation(
                            message, refAttr, Long.valueOf(validationResource.getRow()));
                    validationResource.addViolation(constraintViolation);
                  }
                }
                validationResource.addRefEntityId(getName(), refEntity.getIdValue());
              }
            });
  }
  private void validateEntityValueRequired(Entity entity, ValidationResource validationResource) {
    validationResource
        .getRequiredValueAttrs()
        .forEach(
            nonNillableAttr -> {
              Object value = entity.get(nonNillableAttr.getName());
              if (value == null
                  || (nonNillableAttr.getDataType() instanceof MrefField
                      && !entity.getEntities(nonNillableAttr.getName()).iterator().hasNext())) {
                boolean isValid = false;

                // FIXME remove hack (see https://github.com/molgenis/molgenis/issues/4308)
                // Do not validate if Questionnaire status is not SUBMITTED
                if (EntityUtils.doesExtend(getEntityMetaData(), "Questionnaire")
                    && !"SUBMITTED".equals(entity.getString("status"))) {
                  isValid = true;
                }
                // Do not validate if visibleExpression resolves to false
                else if (nonNillableAttr.getVisibleExpression() != null
                    && !expressionValidator.resolveBooleanExpression(
                        nonNillableAttr.getVisibleExpression(), entity, getEntityMetaData())) {

                  isValid = true;
                }

                if (!isValid) {
                  String message =
                      format(
                          "The attribute '%s' of entity '%s' can not be null.",
                          nonNillableAttr.getName(), getName());

                  ConstraintViolation constraintViolation =
                      new ConstraintViolation(
                          message, nonNillableAttr, Long.valueOf(validationResource.getRow()));
                  validationResource.addViolation(constraintViolation);
                }
              }
            });
  }
Exemple #8
0
  /**
   * Convert an vcfEntity to a VCF line
   *
   * @param vcfEntity
   * @return
   * @throws Exception
   */
  public static String convertToVCF(Entity vcfEntity) throws MolgenisDataException {
    StringBuilder vcfRecord = new StringBuilder();

    List<String> vcfAttributes =
        Arrays.asList(
            new String[] {
              VcfRepository.CHROM,
              VcfRepository.POS,
              VcfRepository.ID,
              VcfRepository.REF,
              VcfRepository.ALT,
              VcfRepository.QUAL,
              VcfRepository.FILTER
            });

    // fixed attributes: chrom pos id ref alt qual filter
    for (String vcfAttribute : vcfAttributes) {
      vcfRecord.append(
          ((vcfEntity.getString(vcfAttribute) != null
                      && !vcfEntity.getString(vcfAttribute).equals(""))
                  ? vcfEntity.getString(vcfAttribute)
                  : ".")
              + TAB);
      // vcfRecord.append(vcfEntity.getString(vcfAttribute) + "\t");
    }

    List<String> infoFieldsSeen = new ArrayList<String>();
    // flexible 'info' field, one column with potentially many data items
    for (AttributeMetaData attributeMetaData :
        vcfEntity.getEntityMetaData().getAttribute(VcfRepository.INFO).getAttributeParts()) {
      infoFieldsSeen.add(attributeMetaData.getName());
      if (vcfEntity.getString(attributeMetaData.getName())
          != null) // FIXME: This removes 'FLAG' fields? see
      // http://samtools.github.io/hts-specs/VCFv4.2.pdf
      {
        if (attributeMetaData.getName().startsWith(VcfRepository.getInfoPrefix())) {
          vcfRecord.append(
              attributeMetaData.getName().substring(VcfRepository.getInfoPrefix().length())
                  + "="
                  + vcfEntity.getString(attributeMetaData.getName())
                  + ";");
        } else {
          vcfRecord.append(
              attributeMetaData.getName()
                  + "="
                  + vcfEntity.getString(attributeMetaData.getName())
                  + ";");
        }
      }
    }

    for (AttributeMetaData attributeMetaData :
        vcfEntity.getEntityMetaData().getAtomicAttributes()) {
      if (!infoFieldsSeen.contains(attributeMetaData.getName())
          && attributeMetaData.getName().startsWith(VcfRepository.getInfoPrefix())
          && vcfEntity.getString(attributeMetaData.getName()) != null) {
        vcfRecord.append(
            attributeMetaData.getName().substring(VcfRepository.getInfoPrefix().length())
                + "="
                + vcfEntity.getString(attributeMetaData.getName())
                + ";");
      }
    }

    // if we have SAMPLE data, add to output VCF
    Iterable<Entity> sampleEntities = vcfEntity.getEntities(VcfRepository.SAMPLES);
    if (sampleEntities != null && !Iterables.isEmpty(sampleEntities)) {
      // add tab
      vcfRecord.append(TAB);
      boolean firstSample = true;

      for (Entity sample : sampleEntities) {
        StringBuilder formatColumn = new StringBuilder();
        StringBuilder sampleColumn = new StringBuilder();

        for (String sampleAttribute : sample.getAttributeNames()) {
          // leave out autogenerated ID and NAME columns since this will greatly bloat the output
          // file for
          // many samples
          // FIXME: chance to clash with existing ID and NAME columns in FORMAT ?? what happens
          // then?
          if (!sampleAttribute.equals(VcfRepository.ID)
              && !sampleAttribute.equals(VcfRepository.NAME)) {
            if (sample.getString(sampleAttribute) != null) {
              sampleColumn.append(sample.getString(sampleAttribute));
              sampleColumn.append(":");
            } else {
              sampleColumn.append(".:");
            }

            // get FORMAT fields, but only for the first time
            if (firstSample) {
              formatColumn.append(sampleAttribute);
              formatColumn.append(":");
            }
          }
        }

        // add FORMAT data but only first time
        if (firstSample && formatColumn.length() > 0) // FIXME: do we expect this??
        {
          formatColumn.deleteCharAt(formatColumn.length() - 1); // delete trailing ':'
          vcfRecord.append(formatColumn.toString() + TAB);
          firstSample = false;
        } else if (firstSample) {
          throw new MolgenisDataException(
              "Weird situation: we are at sample 1 and want to print FORMAT info but there seems to be none?");
        }

        // now add SAMPLE data
        sampleColumn.deleteCharAt(sampleColumn.length() - 1); // delete trailing ':'
        vcfRecord.append(sampleColumn.toString() + TAB);
      }
      // after all samples, delete trailing '\t'
      vcfRecord.deleteCharAt(vcfRecord.length() - 1); // FIXME: need a check??
    }

    return vcfRecord.toString();
  }
 private void createEntityValuesResponseRec(
     Entity entity,
     Iterable<AttributeMetaData> attrs,
     Fetch fetch,
     Map<String, Object> responseData) {
   responseData.put(
       "_href",
       Href.concatEntityHref(BASE_URI, entity.getEntityMetaData().getName(), entity.getIdValue()));
   for (AttributeMetaData attr : attrs) // TODO performance use fetch instead of attrs
   {
     String attrName = attr.getName();
     if (fetch == null || fetch.hasField(attr)) {
       FieldTypeEnum dataType = attr.getDataType().getEnumType();
       switch (dataType) {
         case BOOL:
           responseData.put(attrName, entity.getBoolean(attrName));
           break;
         case CATEGORICAL:
         case XREF:
         case FILE:
           Entity refEntity = entity.getEntity(attrName);
           Map<String, Object> refEntityResponse;
           if (refEntity != null) {
             Fetch refAttrFetch = fetch != null ? fetch.getFetch(attr) : null;
             refEntityResponse = createEntityResponse(refEntity, refAttrFetch, false);
           } else {
             refEntityResponse = null;
           }
           responseData.put(attrName, refEntityResponse);
           break;
         case CATEGORICAL_MREF:
         case MREF:
           Iterable<Entity> refEntities = entity.getEntities(attrName);
           List<Map<String, Object>> refEntityResponses;
           if (refEntities != null) {
             refEntityResponses = new ArrayList<Map<String, Object>>();
             Fetch refAttrFetch = fetch != null ? fetch.getFetch(attrName) : null;
             for (Entity refEntitiesEntity : refEntities) {
               refEntityResponses.add(
                   createEntityResponse(refEntitiesEntity, refAttrFetch, false));
             }
           } else {
             refEntityResponses = null;
           }
           responseData.put(attrName, refEntityResponses);
           break;
         case COMPOUND:
           throw new RuntimeException("Invalid data type [" + dataType + "]");
         case DATE:
           Date dateValue = entity.getDate(attrName);
           String dateValueStr = dateValue != null ? getDateFormat().format(dateValue) : null;
           responseData.put(attrName, dateValueStr);
           break;
         case DATE_TIME:
           Date dateTimeValue = entity.getDate(attrName);
           String dateTimeValueStr =
               dateTimeValue != null ? getDateTimeFormat().format(dateTimeValue) : null;
           responseData.put(attrName, dateTimeValueStr);
           break;
         case DECIMAL:
           responseData.put(attrName, entity.getDouble(attrName));
           break;
         case EMAIL:
         case ENUM:
         case HTML:
         case HYPERLINK:
         case SCRIPT:
         case STRING:
         case TEXT:
           responseData.put(attrName, entity.getString(attrName));
           break;
         case INT:
           responseData.put(attrName, entity.getInt(attrName));
           break;
         case LONG:
           responseData.put(attrName, entity.getLong(attrName));
           break;
         default:
           throw new RuntimeException("Unknown data type [" + dataType + "]");
       }
     }
   }
 }