/** * Sets relationships. * * <p>Looks at merge actions and whether the relationship is empty when adding, so not all * relationships are added. * * @param relationships list of data object relationships or null */ public void setRelationships(List<DataObjectRelationship> relationships) { if (relationships == null) { this.relationships = null; relationshipMap = null; lastAttributeToRelationshipMap = null; attributeToRelationshipMap = null; return; } this.relationships = Collections.unmodifiableList(relationships); relationshipMap = new HashMap<String, DataObjectRelationship>(relationships.size()); attributeToRelationshipMap = new HashMap<String, List<DataObjectRelationship>>(); lastAttributeToRelationshipMap = new HashMap<String, DataObjectRelationship>(relationships.size()); removedRelationshipNames = new ArrayList<String>(); // Builds maps to link attribute names to their relationships for (DataObjectRelationship rel : relationships) { // This is not quite correct - we really only want to not add the NO_OVERRIDE items if they // are // overriding something. However, at the point this is running, we don't know whether we will // be embedding // anything... if (rel.getMergeAction() != MetadataMergeAction.REMOVE && rel.getMergeAction() != MetadataMergeAction.NO_OVERRIDE) { // related object attribute name relationshipMap.put(rel.getName(), rel); // last attribute in list linking the objects if (!rel.getAttributeRelationships().isEmpty()) { DataObjectAttributeRelationship relAttr = rel.getAttributeRelationships().get(rel.getAttributeRelationships().size() - 1); lastAttributeToRelationshipMap.put(relAttr.getParentAttributeName(), rel); } // all relationships relating to an attribute for (DataObjectAttributeRelationship relAttr : rel.getAttributeRelationships()) { List<DataObjectRelationship> rels = attributeToRelationshipMap.get(relAttr.getParentAttributeName()); if (rels == null) { rels = new ArrayList<DataObjectRelationship>(); attributeToRelationshipMap.put(relAttr.getParentAttributeName(), rels); } rels.add(rel); } } // since the attribute will still exist in the embedded metadata, we need to put a block in on // the standard // cascade if (rel.getMergeAction() == MetadataMergeAction.REMOVE) { removedRelationshipNames.add(rel.getName()); } } relationshipMap = Collections.unmodifiableMap(relationshipMap); lastAttributeToRelationshipMap = Collections.unmodifiableMap(lastAttributeToRelationshipMap); attributeToRelationshipMap = Collections.unmodifiableMap(attributeToRelationshipMap); }
/** {@inheritDoc} */ @Override public DataObjectRelationship getRelationship(String relationshipName) { if (relationshipName == null) { return null; } DataObjectRelationship relationship = null; // attempt to get it from the local attribute map (if any attributed defined locally) if (relationships != null) { relationship = relationshipMap.get(relationshipName); } // if we don't find one, but we have an embedded metadata object, check it if (relationship == null && embedded != null) { relationship = embedded.getRelationship(relationshipName); // but, ensure it's not on the removed attribute list if (relationship != null && removedRelationshipNames != null && removedRelationshipNames.contains(relationship.getName())) { relationship = null; } } return relationship; }
/** {@inheritDoc} */ @Override public List<DataObjectRelationship> getRelationshipsInvolvingAttribute(String attributeName) { // somewhat complex, since it returns a list of all possible relationships // if (StringUtils.isBlank(attributeName)) { return null; } Map<Object, DataObjectRelationship> relationships = new HashMap<Object, DataObjectRelationship>(); // Look locally if (attributeToRelationshipMap != null && attributeToRelationshipMap.containsKey(attributeName)) { for (DataObjectRelationship rel : attributeToRelationshipMap.get(attributeName)) { Object mergeKey = rel.getName(); if (rel instanceof MetadataCommonInternal) { mergeKey = ((MetadataCommonInternal) rel).getUniqueKeyForMerging(); } relationships.put(mergeKey, rel); } } // now, if we have an embedded object, look for matching ones, but exclude if the relationship // is the same // as that means it was overridden by this bean if (embedded != null) { for (DataObjectRelationship rel : embedded.getRelationshipsInvolvingAttribute(attributeName)) { Object mergeKey = rel.getName(); if (rel instanceof MetadataCommonInternal) { mergeKey = ((MetadataCommonInternal) rel).getUniqueKeyForMerging(); } if (!relationships.containsKey(mergeKey)) { relationships.put(mergeKey, rel); } } } return new ArrayList<DataObjectRelationship>(relationships.values()); }
protected Control getControlInstance( AttributeDefinition attrDef, DataObjectAttribute dataObjectAttribute) { Control c = null; // Check for the hidden hint - if present - then use that control type if (dataObjectAttribute != null && hasHintOfType(dataObjectAttribute, UifDisplayHintType.HIDDEN)) { c = ComponentFactory.getHiddenControl(); } else if (attrDef.getOptionsFinder() != null) { // if a values finder has been established, use a radio button group or drop-down list if (dataObjectAttribute != null && hasHintOfType(dataObjectAttribute, UifDisplayHintType.RADIO)) { c = ComponentFactory.getRadioGroupControl(); } else { c = ComponentFactory.getSelectControl(); } } else if (attrDef.getName().endsWith(".principalName") && dataObjectAttribute != null) { // FIXME: JHK: Yes, I know this is a *HORRIBLE* hack - but the alternative // would look even more "hacky" and error-prone c = ComponentFactory.getUserControl(); // Need to find the relationship information // get the relationship ID by removing .principalName from the attribute name String relationshipName = StringUtils.removeEnd(attrDef.getName(), ".principalName"); DataObjectMetadata metadata = dataObjectService .getMetadataRepository() .getMetadata(dataObjectAttribute.getOwningType()); if (metadata != null) { DataObjectRelationship relationship = metadata.getRelationship(relationshipName); if (relationship != null && CollectionUtils.isNotEmpty(relationship.getAttributeRelationships())) { ((UserControl) c) .setPrincipalIdPropertyName( relationship.getAttributeRelationships().get(0).getParentAttributeName()); ((UserControl) c) .setPersonNamePropertyName( relationshipName + "." + KimConstants.AttributeConstants.NAME); ((UserControl) c).setPersonObjectPropertyName(relationshipName); } } else { LOG.warn( "Attempt to pull relationship name: " + relationshipName + " resulted in missing metadata when looking for: " + dataObjectAttribute.getOwningType()); } } else { switch (attrDef.getDataType()) { case STRING: // TODO: Determine better way to store the "200" metric below if (attrDef.getMaxLength() != null && attrDef.getMaxLength().intValue() > 200) { c = ComponentFactory.getTextAreaControl(); } else { c = ComponentFactory.getTextControl(); } break; case BOOLEAN: c = ComponentFactory.getCheckboxControl(); break; case DATE: case DATETIME: case TRUNCATED_DATE: c = ComponentFactory.getDateControl(); break; case CURRENCY: case DOUBLE: case FLOAT: case INTEGER: case LARGE_INTEGER: case LONG: case PRECISE_DECIMAL: c = ComponentFactory.getTextControl(); break; case MARKUP: c = ComponentFactory.getTextAreaControl(); break; default: c = ComponentFactory.getTextControl(); break; } } return c; }