Examples with Property eu.esdihumboldt.hale.common.align.model.Property used on opensource projects

Example 21 with Property

use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.

the class ClassificationHandler method getSourceExpressionAsCQL.

/**
 * @see eu.esdihumboldt.hale.io.appschema.writer.internal.AbstractPropertyTransformationHandler#getSourceExpressionAsCQL()
 */
@Override
protected String getSourceExpressionAsCQL() {
    Property source = AppSchemaMappingUtils.getSourceProperty(propertyCell);
    PropertyDefinition sourceDef = source.getDefinition().getDefinition();
    Property target = AppSchemaMappingUtils.getTargetProperty(propertyCell);
    PropertyDefinition targetDef = target.getDefinition().getDefinition();
    String sourceName = source.getDefinition().getDefinition().getName().getLocalPart();
    ListMultimap<String, ParameterValue> parameters = propertyCell.getTransformationParameters();
    LookupTable lookup = ClassificationMappingUtil.getClassificationLookup(parameters, new ServiceManager(ServiceManager.SCOPE_PROJECT));
    if (lookup == null) {
        log.warn("No classification specified");
        return "''";
    } else {
        String cqlTemplate = "if_then_else(in(%s), Recode(%s,%s), %s)";
        // build args to Recode function
        StringBuilder recodeArgsBuilder = new StringBuilder();
        Map<Value, Value> valueMap = lookup.asMap();
        int counter = 0;
        for (Value sourceValue : valueMap.keySet()) {
            Value targetValue = valueMap.get(sourceValue);
            String sourceLiteral = asCqlLiteral(sourceDef, sourceValue.as(String.class));
            String targetLiteral = asCqlLiteral(targetDef, targetValue.as(String.class));
            recodeArgsBuilder.append(sourceLiteral).append(",").append(targetLiteral);
            if (counter < valueMap.size() - 1) {
                recodeArgsBuilder.append(",");
            }
            counter++;
        }
        String recodeArgs = recodeArgsBuilder.toString();
        // build args for in function
        List<String> values = new ArrayList<String>();
        for (Value v : valueMap.keySet()) {
            String valueLiteral = asCqlLiteral(sourceDef, v.as(String.class));
            values.add(valueLiteral);
        }
        values.add(0, sourceName);
        String inArgs = Joiner.on(",").join(values);
        // determine what to put in the "else" branch, based on
        // transformation parameters
        String elsePart = null;
        List<ParameterValue> notClassifiedParam = parameters.get(PARAMETER_NOT_CLASSIFIED_ACTION);
        String notClassifiedAction = null;
        if (notClassifiedParam != null && notClassifiedParam.size() > 0) {
            notClassifiedAction = notClassifiedParam.get(0).as(String.class);
        } else {
            notClassifiedAction = USE_NULL_ACTION;
        }
        if (USE_SOURCE_ACTION.equals(notClassifiedAction))
            elsePart = sourceName;
        else if (notClassifiedAction.startsWith(USE_FIXED_VALUE_ACTION_PREFIX))
            elsePart = asCqlLiteral(targetDef, notClassifiedAction.substring(notClassifiedAction.indexOf(':') + 1));
        else if (USE_NULL_ACTION.equals(notClassifiedAction))
            elsePart = "Expression.NIL";
        return String.format(cqlTemplate, inArgs, sourceName, recodeArgs, elsePart);
    }
}

Example 22 with Property

use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.

the class JoinHandler method handleTypeTransformation.

/**
 * @see eu.esdihumboldt.hale.io.appschema.writer.internal.TypeTransformationHandler#handleTypeTransformation(eu.esdihumboldt.hale.common.align.model.Cell,
 *      eu.esdihumboldt.hale.io.appschema.writer.internal.mapping.AppSchemaMappingContext)
 */
@Override
public FeatureTypeMapping handleTypeTransformation(Cell typeCell, AppSchemaMappingContext context) {
    AppSchemaMappingWrapper mapping = context.getMappingWrapper();
    Alignment alignment = context.getAlignment();
    FeatureChaining featureChaining = context.getFeatureChaining();
    final JoinParameter joinParameter = typeCell.getTransformationParameters().get(PARAMETER_JOIN).get(0).as(JoinParameter.class);
    String validation = joinParameter.validate();
    if (validation != null)
        throw new IllegalArgumentException("Join parameter invalid: " + validation);
    // check only single predicate conditions have been used
    int[] conditionCount = new int[joinParameter.getTypes().size()];
    List<JoinCondition> joinConditions = getSortedJoinConditions(joinParameter);
    for (JoinCondition joinCondition : joinConditions) {
        TypeEntityDefinition joinType = AlignmentUtil.getTypeEntity(joinCondition.joinProperty);
        int typeIdx = joinParameter.getTypes().indexOf(joinType);
        conditionCount[typeIdx]++;
        if (conditionCount[typeIdx] > 1) {
            throw new IllegalArgumentException("Only single condition joins are supported so far");
        }
    }
    FeatureTypeMapping topMostMapping = null;
    for (int chainIdx = 0; chainIdx < joinParameter.getTypes().size() - 1; chainIdx++) {
        ChainConfiguration previousChainConf = null;
        ChainConfiguration chainConf = null;
        if (featureChaining != null) {
            chainConf = featureChaining.getChain(typeCell.getId(), chainIdx);
            if (chainConf != null && chainConf.getPrevChainIndex() >= 0) {
                previousChainConf = featureChaining.getChain(typeCell.getId(), chainConf.getPrevChainIndex());
            }
        }
        // join is done pair-wise: I assume the first type is the container
        // type, whereas the second type is nested in the first
        JoinCondition joinCondition = joinConditions.get(chainIdx);
        baseProperty = joinCondition.baseProperty;
        joinProperty = joinCondition.joinProperty;
        TypeEntityDefinition containerType = AlignmentUtil.getTypeEntity(baseProperty);
        TypeEntityDefinition nestedType = AlignmentUtil.getTypeEntity(joinProperty);
        // build FeatureTypeMapping for container type
        // Entity containerTypeTarget = typeCell.getTarget().values().iterator().next();
        // TypeDefinition containerTypeTargetType = containerTypeTarget.getDefinition().getType();
        EntityDefinition containerTypeTarget = null;
        TypeDefinition containerTypeTargetType = null;
        String containerTypeTargetMappingName = null;
        if (previousChainConf == null) {
            containerTypeTarget = getTargetType(typeCell).getDefinition();
            containerTypeTargetType = containerTypeTarget.getType();
        } else {
            containerTypeTarget = previousChainConf.getNestedTypeTarget();
            containerTypeTargetType = previousChainConf.getNestedTypeTarget().getDefinition().getPropertyType();
            containerTypeTargetMappingName = previousChainConf.getMappingName();
        }
        String containerMappingName = null;
        if (previousChainConf != null) {
            containerMappingName = previousChainConf.getMappingName();
        }
        FeatureTypeMapping containerFTMapping = context.getOrCreateFeatureTypeMapping(containerTypeTargetType, containerMappingName);
        containerFTMapping.setSourceType(containerType.getDefinition().getName().getLocalPart());
        // build FeatureTypeMapping for nested type
        TypeDefinition nestedFT = null;
        List<ChildContext> nestedFTPath = null;
        FeatureTypeMapping nestedFTMapping = null;
        if (chainConf != null) {
            nestedFT = chainConf.getNestedTypeTarget().getDefinition().getPropertyType();
            nestedFTPath = chainConf.getNestedTypeTarget().getPropertyPath();
            // remove last element
            nestedFTPath = nestedFTPath.subList(0, nestedFTPath.size() - 1);
            nestedFTMapping = context.getOrCreateFeatureTypeMapping(nestedFT, chainConf.getMappingName());
            nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
        } else {
            if (joinParameter.getTypes().size() > 2) {
                throw new IllegalArgumentException("If no feature chaining configuration is provided, only join between 2 types is supported");
            }
            // do your best to figure it out on your own... good luck!
            Collection<? extends Cell> propertyCells = alignment.getPropertyCells(typeCell);
            for (Cell propertyCell : propertyCells) {
                Property sourceProperty = AppSchemaMappingUtils.getSourceProperty(propertyCell);
                if (sourceProperty != null) {
                    TypeDefinition sourceType = sourceProperty.getDefinition().getDefinition().getParentType();
                    if (sourceType.getName().equals(nestedType.getDefinition().getName())) {
                        // source property belongs to nested type: determine
                        // target type
                        Property targetProperty = getTargetProperty(propertyCell);
                        // nestedFT =
                        // findOwningFeatureType(targetProperty.getDefinition());
                        nestedFT = findOwningType(targetProperty.getDefinition(), context.getRelevantTargetTypes());
                        if (nestedFT != null && !nestedFT.getName().equals(containerTypeTargetType.getName())) {
                            // target property belongs to a feature type
                            // different from the already mapped one: build
                            // a new mapping
                            nestedFTPath = findOwningTypePath(targetProperty.getDefinition(), context.getRelevantTargetTypes());
                            nestedFTMapping = context.getOrCreateFeatureTypeMapping(nestedFT);
                            nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
                            // in the join
                            break;
                        } else if (isHRefAttribute(targetProperty.getDefinition().getDefinition())) {
                            // check if target property is a href attribute
                            Property hrefProperty = targetProperty;
                            List<ChildContext> hrefPropertyPath = hrefProperty.getDefinition().getPropertyPath();
                            List<ChildContext> hrefContainerPath = hrefPropertyPath.subList(0, hrefPropertyPath.size() - 1);
                            TypeDefinition hrefParentType = hrefProperty.getDefinition().getDefinition().getParentType();
                            // TypeDefinition childFT =
                            // findChildFeatureType(hrefParentType);
                            TypeDefinition childFT = AppSchemaMappingUtils.findChildType(hrefParentType, context.getRelevantTargetTypes());
                            if (childFT != null) {
                                nestedFTPath = hrefContainerPath;
                                nestedFTMapping = context.getOrCreateFeatureTypeMapping(childFT);
                                nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
                                // involved in the join
                                break;
                            }
                        }
                    }
                }
            }
        }
        // build join mapping
        if (nestedFTMapping != null && nestedFTPath != null) {
            AttributeMappingType containerJoinMapping = context.getOrCreateAttributeMapping(containerTypeTargetType, containerTypeTargetMappingName, nestedFTPath);
            containerJoinMapping.setTargetAttribute(mapping.buildAttributeXPath(containerTypeTargetType, nestedFTPath));
            // set isMultiple attribute
            PropertyDefinition targetPropertyDef = nestedFTPath.get(nestedFTPath.size() - 1).getChild().asProperty();
            if (AppSchemaMappingUtils.isMultiple(targetPropertyDef)) {
                containerJoinMapping.setIsMultiple(true);
            }
            AttributeExpressionMappingType containerSourceExpr = new AttributeExpressionMappingType();
            // join column extracted from join condition
            containerSourceExpr.setOCQL(baseProperty.getDefinition().getName().getLocalPart());
            containerSourceExpr.setLinkElement(getLinkElementValue(nestedFTMapping));
            String linkField = context.getUniqueFeatureLinkAttribute(nestedFT, nestedFTMapping.getMappingName());
            containerSourceExpr.setLinkField(linkField);
            containerJoinMapping.setSourceExpression(containerSourceExpr);
            AttributeMappingType nestedJoinMapping = new AttributeMappingType();
            AttributeExpressionMappingType nestedSourceExpr = new AttributeExpressionMappingType();
            // join column extracted from join condition
            nestedSourceExpr.setOCQL(joinProperty.getDefinition().getName().getLocalPart());
            nestedJoinMapping.setSourceExpression(nestedSourceExpr);
            nestedJoinMapping.setTargetAttribute(linkField);
            nestedFTMapping.getAttributeMappings().getAttributeMapping().add(nestedJoinMapping);
        }
        if (chainIdx == 0) {
            topMostMapping = containerFTMapping;
        }
    }
    return topMostMapping;
}

Example 23 with Property

use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.

the class DefaultAlignmentIOTest method testCellDisableSaveLoad.

/**
 * Tests cell disable save and load.
 *
 * @throws Exception if an error occurs
 */
@Test
public void testCellDisableSaveLoad() throws Exception {
    DefaultAlignment baseAlignment = new DefaultAlignment();
    MutableAlignment alignment = new DefaultAlignment();
    Schema schema = TestUtil.loadSchema(getClass().getResource("/testdata/simple/t1.xsd").toURI());
    Iterator<? extends TypeDefinition> iter = schema.getMappingRelevantTypes().iterator();
    TypeDefinition t = iter.next();
    if (!t.getName().getLocalPart().equals("T1")) {
        t = iter.next();
    }
    // generate base alignment
    DefaultCell cell1 = new DefaultCell();
    cell1.setTransformationIdentifier("trans1");
    ListMultimap<String, Type> source = ArrayListMultimap.create();
    source.put(null, new DefaultType(new TypeEntityDefinition(t, SchemaSpaceID.SOURCE, null)));
    cell1.setSource(source);
    ListMultimap<String, Type> target = ArrayListMultimap.create();
    target.put(null, new DefaultType(new TypeEntityDefinition(t, SchemaSpaceID.TARGET, null)));
    cell1.setTarget(target);
    DefaultCell cell2 = new DefaultCell();
    cell2.setTransformationIdentifier("trans2");
    List<ChildContext> childContext2 = new ArrayList<ChildContext>();
    PropertyDefinition child2 = DefinitionUtil.getChild(t, new QName("a1")).asProperty();
    childContext2.add(new ChildContext(child2));
    ListMultimap<String, Property> source2 = ArrayListMultimap.create();
    source2.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext2, SchemaSpaceID.SOURCE, null)));
    cell2.setSource(source2);
    ListMultimap<String, Property> target2 = ArrayListMultimap.create();
    target2.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext2, SchemaSpaceID.TARGET, null)));
    cell2.setTarget(target2);
    DefaultCell cell3 = new DefaultCell();
    cell3.setTransformationIdentifier("trans3");
    List<ChildContext> childContext3 = new ArrayList<ChildContext>();
    PropertyDefinition child3 = DefinitionUtil.getChild(t, new QName("b1")).asProperty();
    childContext3.add(new ChildContext(child3));
    ListMultimap<String, Property> source3 = ArrayListMultimap.create();
    source3.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext3, SchemaSpaceID.SOURCE, null)));
    cell3.setSource(source3);
    ListMultimap<String, Property> target3 = ArrayListMultimap.create();
    target3.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext3, SchemaSpaceID.TARGET, null)));
    cell3.setTarget(target3);
    baseAlignment.addCell(cell1);
    baseAlignment.addCell(cell2);
    String baseDisableCellId = cell2.getId();
    baseAlignment.addCell(cell3);
    String extendedDisableCellId = cell3.getId();
    assertEquals(3, baseAlignment.getCells().size());
    Cell typeCell = baseAlignment.getTypeCells().iterator().next();
    assertEquals(2, baseAlignment.getPropertyCells(typeCell).size());
    // test disable, it should not be with the related property cells
    cell2.setDisabledFor(cell1, true);
    assertEquals(1, baseAlignment.getPropertyCells(typeCell).size());
    assertTrue(cell2.getDisabledFor().contains(cell1.getId()));
    cell2.setDisabledFor(cell1, false);
    assertFalse(cell2.getDisabledFor().contains(cell1.getId()));
    cell2.setDisabledFor(cell1, true);
    assertEquals(1, baseAlignment.getPropertyCells(typeCell).size());
    // save base alignment
    File baseAlignmentFile = tmp.newFile("alignment_base.xml");
    System.out.println(baseAlignmentFile.getAbsolutePath());
    saveAlignment(baseAlignment, new BufferedOutputStream(new FileOutputStream(baseAlignmentFile)));
    // load base alignment
    MutableAlignment baseAlignment2 = loadAlignment(new FileInputStream(baseAlignmentFile), schema, schema);
    typeCell = baseAlignment2.getTypeCells().iterator().next();
    assertEquals(3, baseAlignment2.getCells().size());
    // test again that it is still disabled
    assertEquals(1, baseAlignment2.getPropertyCells(typeCell).size());
    // disable the remaining enabled cell in extended alignment
    addBaseAlignment(alignment, baseAlignmentFile.toURI(), schema, schema);
    assertEquals(1, alignment.getBaseAlignments().size());
    String usedPrefix = alignment.getBaseAlignments().keySet().iterator().next();
    File alignmentFile = tmp.newFile("alignment_extended.xml");
    // check cells
    typeCell = alignment.getTypeCells().iterator().next();
    assertEquals(3, alignment.getCells().size());
    assertEquals(1, alignment.getPropertyCells(typeCell).size());
    // disable remaining cell
    ((ModifiableCell) alignment.getPropertyCells(typeCell, false, false).iterator().next()).setDisabledFor(typeCell, true);
    assertEquals(0, alignment.getPropertyCells(typeCell).size());
    // save / load extended alignment
    System.out.println(alignmentFile.getAbsolutePath());
    saveAlignment(alignment, new BufferedOutputStream(new FileOutputStream(alignmentFile)));
    // load extended
    MutableAlignment alignment2 = loadAlignment(new FileInputStream(alignmentFile), schema, schema);
    typeCell = alignment2.getTypeCells().iterator().next();
    // test disabled again
    assertEquals(3, alignment2.getCells().size());
    // test again that it is still disabled
    assertEquals(0, alignment2.getPropertyCells(typeCell).size());
    // more specifically test whether the disables come from base alignment
    // or extended alignment
    Cell baseDisableCell = alignment2.getCell(usedPrefix + ":" + baseDisableCellId);
    Cell extendedDisableCell = alignment2.getCell(usedPrefix + ":" + extendedDisableCellId);
    assertTrue(baseDisableCell instanceof BaseAlignmentCell);
    assertEquals(1, baseDisableCell.getDisabledFor().size());
    assertEquals(1, ((BaseAlignmentCell) baseDisableCell).getBaseDisabledFor().size());
    assertEquals(0, ((BaseAlignmentCell) baseDisableCell).getAdditionalDisabledFor().size());
    assertTrue(extendedDisableCell instanceof BaseAlignmentCell);
    assertEquals(1, extendedDisableCell.getDisabledFor().size());
    assertEquals(0, ((BaseAlignmentCell) extendedDisableCell).getBaseDisabledFor().size());
    assertEquals(1, ((BaseAlignmentCell) extendedDisableCell).getAdditionalDisabledFor().size());
}

Example 24 with Property

use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.

the class PropertyEntitySelector method createFilters.

private static ViewerFilter[] createFilters(PropertyParameterDefinition field) {
    // if no condition is present add a filter that allows all properties
    ViewerFilter propertyFilter = new ViewerFilter() {

        @Override
        public boolean select(Viewer viewer, Object parentElement, Object element) {
            return element instanceof PropertyEntityDefinition;
        }
    };
    if (field == null) {
        return new ViewerFilter[] { propertyFilter };
    }
    List<PropertyCondition> conditions = field.getConditions();
    if (conditions == null || conditions.isEmpty())
        return new ViewerFilter[] { propertyFilter };
    ViewerFilter[] filters = new ViewerFilter[conditions.size()];
    int i = 0;
    for (final PropertyCondition condition : conditions) {
        filters[i] = new ViewerFilter() {

            @Override
            public boolean select(Viewer viewer, Object parentElement, Object element) {
                if (element instanceof PropertyEntityDefinition) {
                    Property property = new DefaultProperty((PropertyEntityDefinition) element);
                    return condition.accept(property);
                } else
                    return false;
            }
        };
    }
    return filters;
}

Example 25 with Property

use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.

the class EntityDefinitionServiceImpl method replace.

/**
 * Creates a new ListMultimap with all occurrences of originalDef replaced
 * by newDef. newDef must be a sibling of originalDef.
 *
 * @param entities the original list
 * @param originalDef the entity definition to be replaced
 * @param newDef the entity definition to use
 * @return a new list
 */
private ListMultimap<String, ? extends Entity> replace(ListMultimap<String, ? extends Entity> entities, EntityDefinition originalDef, EntityDefinition newDef) {
    ListMultimap<String, Entity> newList = ArrayListMultimap.create();
    for (Entry<String, ? extends Entity> entry : entities.entries()) {
        EntityDefinition entryDef = entry.getValue().getDefinition();
        Entity newEntry;
        if (AlignmentUtil.isParent(originalDef, entryDef)) {
            if (entry.getValue() instanceof Type) {
                // entry is a Type, so the changed Definition must be a
                // Type, too.
                newEntry = new DefaultType((TypeEntityDefinition) newDef);
            } else if (entry.getValue() instanceof Property) {
                // entry is a Property, check changed Definition.
                if (originalDef.getPropertyPath().isEmpty()) {
                    // Type changed.
                    newEntry = new DefaultProperty(new PropertyEntityDefinition(newDef.getType(), entryDef.getPropertyPath(), entryDef.getSchemaSpace(), newDef.getFilter()));
                } else {
                    // Some element of the property path changed.
                    List<ChildContext> newPath = new ArrayList<ChildContext>(entryDef.getPropertyPath());
                    int lastIndexOfChangedDef = newDef.getPropertyPath().size() - 1;
                    newPath.set(lastIndexOfChangedDef, newDef.getPropertyPath().get(lastIndexOfChangedDef));
                    newEntry = new DefaultProperty(new PropertyEntityDefinition(entryDef.getType(), newPath, entryDef.getSchemaSpace(), entryDef.getFilter()));
                }
            } else {
                throw new IllegalStateException("Entity is neither a Type nor a Property.");
            }
        } else {
            newEntry = entry.getValue();
        }
        newList.put(entry.getKey(), newEntry);
    }
    return newList;
}