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);
}
}
@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);
}
}
});
}
/**
* 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 + "]");
}
}
}
}