How to use

ResourceAttributeContainerDefinition

in

com.evolveum.midpoint.schema.processor

/**
 * Returns true if the attribute is a (primary) identifier.
 *
 * Convenience method.
 *
 * @return true if the attribute is a (primary) identifier.
 */
@Override
public boolean isPrimaryIdentifier(ResourceAttributeContainerDefinition objectDefinition) {
  return isPrimaryIdentifier(objectDefinition.getComplexTypeDefinition());
}

@Override
public Collection<ResourceAttribute<?>> getAllIdentifiers() {
  return extractAttributesByDefinitions(getDefinition().getAllIdentifiers());
}

private void checkResourceObjectDefinition(ResourceAttributeContainerDefinition rod)
    throws SchemaException {
  for (ItemDefinition def : rod.getDefinitions()) {
    if (!(def instanceof ResourceAttributeDefinition)) {
      throw new SchemaException("Unexpected definition in resource schema object " + rod + ": "
          + def);
    }
  }
}

private void assertAttributeDefs(ResourceAttributeContainerDefinition attrsDef, ResourceType resourceType, LayerType sourceLayer, LayerType validationLayer) {
  assertNotNull("Null account definition", attrsDef);
  assertEquals(SchemaConstants.INTENT_DEFAULT, attrsDef.getIntent());
  assertEquals("AccountObjectClass", attrsDef.getComplexTypeDefinition().getTypeName().getLocalPart());
  assertEquals("Wrong objectclass in the definition of <attributes> definition in account", RefinedObjectClassDefinitionImpl.class, attrsDef.getComplexTypeDefinition().getClass());
  RefinedObjectClassDefinition rAccount = (RefinedObjectClassDefinition) attrsDef.getComplexTypeDefinition();
  assertRObjectClassDef(rAccount, resourceType, sourceLayer, validationLayer);
}

assertNotNull("No ResourceAttributeContainerDefinition", resAttrContainerDef);
System.out.println("\nResourceAttributeContainerDefinition ("+sourceLayer+")");
System.out.println(resAttrContainerDef.debugDump());
ObjectClassComplexTypeDefinition rComplexTypeDefinition = resAttrContainerDef.getComplexTypeDefinition();
System.out.println("\nResourceAttributeContainerDefinition ComplexTypeDefinition ("+sourceLayer+")");
System.out.println(rComplexTypeDefinition.debugDump());
assertRefinedToLayer(rComplexTypeDefinition, sourceLayer);
ResourceAttributeDefinition riUidAttrDef = resAttrContainerDef.findAttributeDefinition(new ItemName(resourceType.getNamespace(), "uid"));
assertNotNull("No ri:uid def in ResourceAttributeContainerDefinition", riUidAttrDef);
System.out.println("\nri:uid def "+riUidAttrDef.getClass()+" ("+sourceLayer+")");
Collection<? extends ResourceAttributeDefinition> definitionsFromResAttrContainerDef = resAttrContainerDef.getDefinitions();
for (ResourceAttributeDefinition definitionFromResAttrContainerDef: definitionsFromResAttrContainerDef) {
  assertRefinedToLayer(definitionFromResAttrContainerDef, sourceLayer);

    .findOrCreateContainer(ShadowType.F_ATTRIBUTES);
ResourceAttributeContainerDefinition attributesContainerDefinition = attributesContainer.getDefinition();
shadow.setObjectClass(attributesContainerDefinition.getTypeName());
  ResourceAttributeDefinition attributeDefinition = attributesContainerDefinition.findAttributeDefinition(qname, caseIgnoreAttributeNames);
      throw new SchemaException("Unknown attribute " + qname + " in definition of object class " + attributesContainerDefinition.getTypeName()
      + ". Original ConnId name: " + connIdAttr.getName() + " in resource object identified by " + co.getName(), qname);
ObjectClassComplexTypeDefinition ocDef = attributesContainerDefinition.getComplexTypeDefinition();
ResourceAttributeDefinition<String> uidDefinition = ConnIdUtil.getUidDefinition(ocDef);
if (uidDefinition == null) {

assertNotNull("No ResourceAttributeContainerDefinition", resAttrContainerDef);
System.out.println("\nResourceAttributeContainerDefinition");
System.out.println(resAttrContainerDef.debugDump());
ObjectClassComplexTypeDefinition rComplexTypeDefinition = resAttrContainerDef.getComplexTypeDefinition();
System.out.println("\nResourceAttributeContainerDefinition ComplexTypeDefinition");
System.out.println(rComplexTypeDefinition.debugDump());
ResourceAttributeDefinition<String> riUidAttrDef = resAttrContainerDef.findAttributeDefinition(new ItemName(resourceType.getNamespace(), "uid"));
assertNotNull("No ri:uid def in ResourceAttributeContainerDefinition", riUidAttrDef);
System.out.println("\nri:uid def "+riUidAttrDef.getClass());

  throw new IllegalStateException("No definition for " + attributes);
List<QName> identifiers = attributesDefinition.getAllIdentifiers().stream().map(ItemDefinition::getName).collect(Collectors.toList());
List<QName> outstandingInRepo;
PrismContainer<?> repoAttributes = repoShadowBefore.findContainer(ShadowType.F_ATTRIBUTES);
  boolean isIdentifier = QNameUtil.matchAny(outstanding, identifiers);
  if (!isIdentifier) {
    ResourceAttributeDefinition<?> outstandingDefinition = attributesDefinition.findAttributeDefinition(ItemName.fromQName(outstanding));
    if (outstandingDefinition == null) {
      continue;       // cannot do anything with this

protected <T> void addAttributeToShadow(PrismObject<ShadowType> shadow, PrismObject<ResourceType> resource, String attrName, T attrValue) throws SchemaException {
  ResourceAttributeContainer attrs = ShadowUtil.getAttributesContainer(shadow);
  ResourceAttributeDefinition attrSnDef = attrs.getDefinition().findAttributeDefinition(
       new ItemName(ResourceTypeUtil.getResourceNamespace(resource), attrName));
  ResourceAttribute<T> attr = attrSnDef.instantiate();
  attr.setRealValue(attrValue);
  attrs.add(attr);
}

if (def instanceof ResourceAttributeContainerDefinition) {
  ResourceAttributeContainerDefinition rdef = (ResourceAttributeContainerDefinition) def;
  assertNotEmpty("No type name in object class", rdef.getTypeName());
  assertNotEmpty("No native object class for " + rdef.getTypeName(),
      rdef.getNativeObjectClass());
  assertNotEmpty("No name for " + rdef.getTypeName(), rdef.getName());

public ObjectClass objectClassToConnId(PrismObject<? extends ShadowType> shadow, String schemaNamespace, ConnectorType connectorType, boolean legacySchema) {
  ShadowType shadowType = shadow.asObjectable();
  QName qnameObjectClass = shadowType.getObjectClass();
  if (qnameObjectClass == null) {
    ResourceAttributeContainer attrContainer = ShadowUtil.getAttributesContainer(shadowType);
    if (attrContainer == null) {
      return null;
    }
    ResourceAttributeContainerDefinition objectClassDefinition = attrContainer.getDefinition();
    qnameObjectClass = objectClassDefinition.getTypeName();
  }
  return objectClassToConnId(qnameObjectClass, schemaNamespace, connectorType, legacySchema);
}

/**
 * Returns the native object class string for the resource object.
 *
 * Native object class is the name of the Resource Object Definition (Object
 * Class) as it is seen by the resource itself. The name of the Resource
 * Object Definition may be constrained by XSD or other syntax and therefore
 * may be "mangled" to conform to such syntax. The <i>native object
 * class</i> value will contain unmangled name (if available).
 *
 * Returns null if there is no native object class or the native object
 * class is not known.
 *
 * The exception should be never thrown unless there is some bug in the
 * code. The validation of model consistency should be done at the time of
 * schema parsing.
 *
 * @return native object class
 * @throws IllegalStateException
 *             if there is more than one description attribute.
 */
@Override
public String getNativeObjectClass() {
  return getDefinition() == null ? null : getDefinition().getNativeObjectClass();
}

protected void checkUniqueness(PrismObject<? extends ShadowType> object) throws SchemaException {
  OperationResult result = new OperationResult(TestDummyNegative.class.getName()
      + ".checkConsistency");
  PrismPropertyDefinition itemDef = ShadowUtil.getAttributesContainer(object).getDefinition().findAttributeDefinition(SchemaConstants.ICFS_NAME);
  LOGGER.info("item definition: {}", itemDef.debugDump());
  //TODO: matching rule
  ObjectQuery query = prismContext.queryFor(ShadowType.class)
      .itemWithDef(itemDef, ShadowType.F_ATTRIBUTES, itemDef.getName()).eq(getWillRepoIcfName())
      .build();
  System.out.println("Looking for shadows of \"" + getWillRepoIcfName() + "\" with filter "
      + query.debugDump());
  display("Looking for shadows of \"" + getWillRepoIcfName() + "\" with filter "
      + query.debugDump());
  List<PrismObject<ShadowType>> objects = repositoryService.searchObjects(ShadowType.class, query,
      null, result);
  assertEquals("Wrong number of repo shadows for ICF NAME \"" + getWillRepoIcfName() + "\"", 1, objects.size());
}

resultShadowType.setObjectClass(resourceAttributesContainer.getDefinition().getTypeName());

public QName convertAttributeNameToQName(String icfAttrName, ResourceAttributeContainerDefinition attributesContainerDefinition) {
  return convertAttributeNameToQName(icfAttrName, attributesContainerDefinition.getComplexTypeDefinition());
}

repoShadowType.setObjectClass(attributesContainer.getDefinition().getTypeName());

public static ObjectClassComplexTypeDefinition getObjectClassDefinition(ShadowType shadow) {
  // TODO: maybe we can do something more intelligent here
  ResourceAttributeContainer attributesContainer = getAttributesContainer(shadow);
  return attributesContainer.getDefinition().getComplexTypeDefinition();
}

public static ObjectClassComplexTypeDefinition getObjectClassDefinition(PrismObject<? extends ShadowType> shadow) {
  // TODO: maybe we can do something more intelligent here
  ResourceAttributeContainer attributesContainer = getAttributesContainer(shadow);
  return attributesContainer.getDefinition().getComplexTypeDefinition();
}

public static void assertProvisioningShadow(PrismObject<ShadowType> account, ResourceType resourceType,
                          Class<?> expetcedAttributeDefinitionClass, QName objectClass) {
  // Check attribute definition
  PrismContainer attributesContainer = account.findContainer(ShadowType.F_ATTRIBUTES);
  PrismAsserts.assertClass("Wrong attributes container class", ResourceAttributeContainer.class, attributesContainer);
  ResourceAttributeContainer rAttributesContainer = (ResourceAttributeContainer)attributesContainer;
  PrismContainerDefinition attrsDef = attributesContainer.getDefinition();
  assertNotNull("No attributes container definition", attrsDef);
  assertTrue("Wrong attributes definition class "+attrsDef.getClass().getName(), attrsDef instanceof ResourceAttributeContainerDefinition);
  ResourceAttributeContainerDefinition rAttrsDef = (ResourceAttributeContainerDefinition)attrsDef;
  ObjectClassComplexTypeDefinition objectClassDef = rAttrsDef.getComplexTypeDefinition();
  assertNotNull("No object class definition in attributes definition", objectClassDef);
  assertEquals("Wrong object class in attributes definition", objectClass, objectClassDef.getTypeName());
  ResourceAttributeDefinition primaryIdDef = objectClassDef.getPrimaryIdentifiers().iterator().next();
  ResourceAttribute<?> primaryIdAttr = rAttributesContainer.findAttribute(primaryIdDef.getName());
  assertNotNull("No primary ID "+primaryIdDef.getName()+" in "+account, primaryIdAttr);
  assertAttributeDefinition(primaryIdAttr, DOMUtil.XSD_STRING, 0, 1, true, false, false, expetcedAttributeDefinitionClass);
  ResourceAttributeDefinition secondaryIdDef = objectClassDef.getSecondaryIdentifiers().iterator().next();
  ResourceAttribute<Object> secondaryIdAttr = rAttributesContainer.findAttribute(secondaryIdDef.getName());
  assertNotNull("No secondary ID "+secondaryIdDef.getName()+" in "+account, secondaryIdAttr);
  assertAttributeDefinition(secondaryIdAttr, DOMUtil.XSD_STRING, 1, 1, true, true, true, expetcedAttributeDefinitionClass);
}

@Test
public void test500FetchObject() throws Exception {
  final String TEST_NAME = "test500FetchObject";
  TestUtil.displayTestTitle(this, TEST_NAME);
  // GIVEN
  ResourceAttributeContainer resourceObject = createResourceObject(
      "uid=Teell,ou=People,dc=example,dc=com", "Teell William", "Teell");
  OperationResult addResult = new OperationResult(this.getClass().getName() + "." + TEST_NAME);
  PrismObject<ShadowType> shadow = wrapInShadow(ShadowType.class, resourceObject);
  // Add a testing object
  cc.addObject(shadow, null, null, addResult);
  ObjectClassComplexTypeDefinition accountDefinition = resourceObject.getDefinition().getComplexTypeDefinition();
  Collection<ResourceAttribute<?>> identifiers = resourceObject.getPrimaryIdentifiers();
  // Determine object class from the schema
  ResourceObjectIdentification identification = new ResourceObjectIdentification(accountDefinition, identifiers, null);
  OperationResult result = new OperationResult(this.getClass().getName() + "." + TEST_NAME);
  // WHEN
  PrismObject<ShadowType> ro = cc.fetchObject(identification, null, null, result);
  // THEN
  AssertJUnit.assertNotNull(ro);
  System.out.println("Fetched object " + ro);
  System.out.println("Result:");
  System.out.println(result.debugDump());
}