@Override
  public void setObject(Object object) {
    try {
      PrismProperty property = getPrismObject().findOrCreateProperty(path);

      if (object != null) {
        PrismPropertyDefinition def = property.getDefinition();
        if (PolyString.class.equals(def.getTypeClass())) {
          object = new PolyString((String) object);
        }

        property.setValue(new PrismPropertyValue(object, OriginType.USER_ACTION, null));
      } else {
        PrismContainerValue parent = (PrismContainerValue) property.getParent();
        parent.remove(property);
      }
    } catch (Exception ex) {
      LoggingUtils.logException(LOGGER, "Couldn't update prism property model", ex);
    }
  }
  private void fillInUserDrake(PrismObject<UserType> user, boolean assertDefinitions)
      throws SchemaException {
    user.setOid(USER_OID);

    // fullName
    PrismProperty<String> fullNameProperty = user.findOrCreateProperty(USER_FULLNAME_QNAME);
    assertEquals(USER_FULLNAME_QNAME, fullNameProperty.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions)
      PrismAsserts.assertDefinition(fullNameProperty, DOMUtil.XSD_STRING, 1, 1);
    fullNameProperty.setValue(new PrismPropertyValue<String>("Sir Fancis Drake"));
    PrismProperty<String> fullNamePropertyAgain = user.findOrCreateProperty(USER_FULLNAME_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Property not the same", fullNameProperty == fullNamePropertyAgain);

    // activation
    PrismContainer<ActivationType> activationContainer =
        user.findOrCreateContainer(USER_ACTIVATION_QNAME);
    assertEquals(USER_ACTIVATION_QNAME, activationContainer.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions)
      PrismAsserts.assertDefinition(activationContainer, ACTIVATION_TYPE_QNAME, 0, 1);
    PrismContainer<ActivationType> activationContainerAgain =
        user.findOrCreateContainer(USER_ACTIVATION_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Property not the same", activationContainer == activationContainerAgain);

    // activation/enabled
    PrismProperty<Boolean> enabledProperty = user.findOrCreateProperty(USER_ENABLED_PATH);
    assertEquals(USER_ENABLED_QNAME, enabledProperty.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions)
      PrismAsserts.assertDefinition(enabledProperty, DOMUtil.XSD_BOOLEAN, 0, 1);
    enabledProperty.setValue(new PrismPropertyValue<Boolean>(true));
    PrismProperty<Boolean> enabledPropertyAgain =
        activationContainer.findOrCreateProperty(USER_ENABLED_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Property not the same", enabledProperty == enabledPropertyAgain);

    // assignment
    // Try to create this one from the value. It should work the same, but let's test a different
    // code path
    PrismContainer<AssignmentType> assignmentContainer =
        user.getValue().findOrCreateContainer(USER_ASSIGNMENT_QNAME);
    assertEquals(USER_ASSIGNMENT_QNAME, assignmentContainer.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions)
      PrismAsserts.assertDefinition(assignmentContainer, ASSIGNMENT_TYPE_QNAME, 0, -1);
    PrismContainer<AssignmentType> assignmentContainerAgain =
        user.findOrCreateContainer(USER_ASSIGNMENT_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Property not the same", assignmentContainer == assignmentContainerAgain);
    assertEquals(
        "Wrong number of assignment values (empty)", 0, assignmentContainer.getValues().size());

    // assignment values: construct assignment value as a new container "out of the blue" and then
    // add it.
    PrismContainer<AssignmentType> assBlueContainer =
        new PrismContainer<AssignmentType>(USER_ASSIGNMENT_QNAME);
    PrismProperty<String> assBlueDescriptionProperty =
        assBlueContainer.findOrCreateProperty(USER_DESCRIPTION_QNAME);
    assBlueDescriptionProperty.addValue(
        new PrismPropertyValue<String>("Assignment created out of the blue"));
    PrismAsserts.assertParentConsistency(user);
    assignmentContainer.mergeValues(assBlueContainer);
    assertEquals(
        "Wrong number of assignment values (after blue)",
        1,
        assignmentContainer.getValues().size());
    PrismAsserts.assertParentConsistency(user);

    // assignment values: construct assignment value as a new container value "out of the blue" and
    // then add it.
    PrismContainerValue<AssignmentType> assCyanContainerValue =
        new PrismContainerValue<AssignmentType>();
    PrismProperty<String> assCyanDescriptionProperty =
        assCyanContainerValue.findOrCreateProperty(USER_DESCRIPTION_QNAME);
    assCyanDescriptionProperty.addValue(
        new PrismPropertyValue<String>("Assignment created out of the cyan"));
    assignmentContainer.mergeValue(assCyanContainerValue);
    assertEquals(
        "Wrong number of assignment values (after cyan)",
        2,
        assignmentContainer.getValues().size());
    PrismAsserts.assertParentConsistency(user);

    // assignment values: construct assignment value from existing container
    PrismContainerValue<AssignmentType> assRedContainerValue = assignmentContainer.createNewValue();
    PrismProperty<String> assRedDescriptionProperty =
        assRedContainerValue.findOrCreateProperty(USER_DESCRIPTION_QNAME);
    assRedDescriptionProperty.addValue(
        new PrismPropertyValue<String>("Assignment created out of the red"));
    assertEquals(
        "Wrong number of assignment values (after red)", 3, assignmentContainer.getValues().size());
    PrismAsserts.assertParentConsistency(user);

    // accountRef
    PrismReference accountRef = user.findOrCreateReference(USER_ACCOUNTREF_QNAME);
    assertEquals(USER_ACCOUNTREF_QNAME, accountRef.getElementName());
    if (assertDefinitions)
      PrismAsserts.assertDefinition(accountRef, OBJECT_REFERENCE_TYPE_QNAME, 0, -1);
    accountRef.add(new PrismReferenceValue(ACCOUNT1_OID));
    accountRef.add(new PrismReferenceValue(ACCOUNT2_OID));
    PrismReference accountRefAgain = user.findOrCreateReference(USER_ACCOUNTREF_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Property not the same", accountRef == accountRefAgain);
    assertEquals("accountRef size", 2, accountRef.getValues().size());
    PrismAsserts.assertParentConsistency(user);

    // extension
    PrismContainer<?> extensionContainer = user.findOrCreateContainer(USER_EXTENSION_QNAME);
    assertEquals(USER_EXTENSION_QNAME, extensionContainer.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions) PrismAsserts.assertDefinition(extensionContainer, DOMUtil.XSD_ANY, 0, 1);
    PrismContainer<AssignmentType> extensionContainerAgain =
        user.findOrCreateContainer(USER_EXTENSION_QNAME);
    // The "==" is there by purpose. We really want to make sure that is the same *instance*, that
    // is was not created again
    assertTrue("Extension not the same", extensionContainer == extensionContainerAgain);
    assertEquals(
        "Wrong number of extension values (empty)", 0, extensionContainer.getValues().size());

    // extension / stringType
    PrismProperty<String> stringTypeProperty =
        extensionContainer.findOrCreateProperty(EXTENSION_STRING_TYPE_ELEMENT);
    assertEquals(EXTENSION_STRING_TYPE_ELEMENT, stringTypeProperty.getElementName());
    PrismAsserts.assertParentConsistency(user);
    if (assertDefinitions)
      PrismAsserts.assertDefinition(stringTypeProperty, DOMUtil.XSD_STRING, 0, -1);

    // TODO

  }
  private List<ItemWrapper> createProperties(PageBase pageBase) {
    result = new OperationResult(CREATE_PROPERTIES);

    List<ItemWrapper> properties = new ArrayList<ItemWrapper>();

    PrismContainerDefinition definition = null;
    PrismObject parent = getObject().getObject();
    Class clazz = parent.getCompileTimeClass();
    if (ShadowType.class.isAssignableFrom(clazz)) {
      QName name = containerDefinition.getName();

      if (ShadowType.F_ATTRIBUTES.equals(name)) {
        try {
          definition = objectWrapper.getRefinedAttributeDefinition();

          if (definition == null) {
            PrismReference resourceRef = parent.findReference(ShadowType.F_RESOURCE_REF);
            PrismObject<ResourceType> resource = resourceRef.getValue().getObject();

            definition =
                pageBase
                    .getModelInteractionService()
                    .getEditObjectClassDefinition(
                        (PrismObject<ShadowType>) objectWrapper.getObject(),
                        resource,
                        AuthorizationPhaseType.REQUEST)
                    .toResourceAttributeContainerDefinition();

            if (LOGGER.isTraceEnabled()) {
              LOGGER.trace("Refined account def:\n{}", definition.debugDump());
            }
          }
        } catch (Exception ex) {
          LoggingUtils.logException(
              LOGGER, "Couldn't load definitions from refined schema for shadow", ex);
          result.recordFatalError(
              "Couldn't load definitions from refined schema for shadow, reason: "
                  + ex.getMessage(),
              ex);

          return properties;
        }
      } else {
        definition = containerDefinition;
      }
    } else if (ResourceType.class.isAssignableFrom(clazz)) {
      if (containerDefinition != null) {
        definition = containerDefinition;
      } else {
        definition = container.getDefinition();
      }
    } else {
      definition = containerDefinition;
    }

    if (definition == null) {
      LOGGER.error(
          "Couldn't get property list from null definition {}",
          new Object[] {container.getElementName()});
      return properties;
    }

    // assignments are treated in a special way -- we display names of
    // org.units and roles
    // (but only if ObjectWrapper.isShowAssignments() is true; otherwise
    // they are filtered out by ObjectWrapper)
    if (container.getCompileTimeClass() != null
        && AssignmentType.class.isAssignableFrom(container.getCompileTimeClass())) {

      for (Object o : container.getValues()) {
        PrismContainerValue<AssignmentType> pcv = (PrismContainerValue<AssignmentType>) o;

        AssignmentType assignmentType = pcv.asContainerable();

        if (assignmentType.getTargetRef() == null) {
          continue;
        }

        // hack... we want to create a definition for Name
        // PrismPropertyDefinition def = ((PrismContainerValue)
        // pcv.getContainer().getParent()).getContainer().findProperty(ObjectType.F_NAME).getDefinition();
        PrismPropertyDefinition def =
            new PrismPropertyDefinition(
                ObjectType.F_NAME, DOMUtil.XSD_STRING, pcv.getPrismContext());

        if (OrgType.COMPLEX_TYPE.equals(assignmentType.getTargetRef().getType())) {
          def.setDisplayName("Org.Unit");
          def.setDisplayOrder(100);
        } else if (RoleType.COMPLEX_TYPE.equals(assignmentType.getTargetRef().getType())) {
          def.setDisplayName("Role");
          def.setDisplayOrder(200);
        } else {
          continue;
        }

        PrismProperty<Object> temp = def.instantiate();

        String value = formatAssignmentBrief(assignmentType);

        temp.setValue(new PrismPropertyValue<Object>(value));
        // TODO: do this.isReadOnly() - is that OK? (originally it was the default behavior for all
        // cases)
        properties.add(new PropertyWrapper(this, temp, this.isReadonly(), ValueStatus.NOT_CHANGED));
      }

    } else if (isShadowAssociation()) {
      PrismContext prismContext = objectWrapper.getObject().getPrismContext();
      Map<QName, PrismContainer<ShadowAssociationType>> assocMap = new HashMap<>();
      if (objectWrapper.getAssociations() != null) {
        for (PrismContainerValue<ShadowAssociationType> cval : objectWrapper.getAssociations()) {
          ShadowAssociationType associationType = cval.asContainerable();
          QName assocName = associationType.getName();
          PrismContainer<ShadowAssociationType> fractionalContainer = assocMap.get(assocName);
          if (fractionalContainer == null) {
            fractionalContainer =
                new PrismContainer<>(
                    ShadowType.F_ASSOCIATION, ShadowAssociationType.class, cval.getPrismContext());
            fractionalContainer.setDefinition(cval.getParent().getDefinition());
            // HACK: set the name of the association as the element name so wrapper.getName() will
            // return correct data.
            fractionalContainer.setElementName(assocName);
            assocMap.put(assocName, fractionalContainer);
          }
          try {
            fractionalContainer.add(cval.clone());
          } catch (SchemaException e) {
            // Should not happen
            throw new SystemException("Unexpected error: " + e.getMessage(), e);
          }
        }
      }

      PrismReference resourceRef = parent.findReference(ShadowType.F_RESOURCE_REF);
      PrismObject<ResourceType> resource = resourceRef.getValue().getObject();

      // HACK. The revive should not be here. Revive is no good. The next use of the resource will
      // cause parsing of resource schema. We need some centralized place to maintain live cached
      // copies
      // of resources.
      try {
        resource.revive(prismContext);
      } catch (SchemaException e) {
        throw new SystemException(e.getMessage(), e);
      }
      RefinedResourceSchema refinedSchema;
      CompositeRefinedObjectClassDefinition rOcDef;
      try {
        refinedSchema = RefinedResourceSchema.getRefinedSchema(resource);
        rOcDef = refinedSchema.determineCompositeObjectClassDefinition(parent);
      } catch (SchemaException e) {
        throw new SystemException(e.getMessage(), e);
      }
      // Make sure even empty associations have their wrappers so they can be displayed and edited
      for (RefinedAssociationDefinition assocDef : rOcDef.getAssociations()) {
        QName name = assocDef.getName();
        if (!assocMap.containsKey(name)) {
          PrismContainer<ShadowAssociationType> fractionalContainer =
              new PrismContainer<>(
                  ShadowType.F_ASSOCIATION, ShadowAssociationType.class, prismContext);
          fractionalContainer.setDefinition(getItemDefinition());
          // HACK: set the name of the association as the element name so wrapper.getName() will
          // return correct data.
          fractionalContainer.setElementName(name);
          assocMap.put(name, fractionalContainer);
        }
      }

      for (Entry<QName, PrismContainer<ShadowAssociationType>> assocEntry : assocMap.entrySet()) {
        // HACK HACK HACK, the container wrapper should not parse itself. This code should not be
        // here.
        AssociationWrapper assocWrapper =
            new AssociationWrapper(
                this, assocEntry.getValue(), this.isReadonly(), ValueStatus.NOT_CHANGED);
        properties.add(assocWrapper);
      }

    } else { // if not an assignment

      if ((container.getValues().size() == 1 || container.getValues().isEmpty())
          && (containerDefinition == null || containerDefinition.isSingleValue())) {

        // there's no point in showing properties for non-single-valued
        // parent containers,
        // so we continue only if the parent is single-valued

        Collection<ItemDefinition> propertyDefinitions = definition.getDefinitions();
        for (ItemDefinition itemDef : propertyDefinitions) {
          if (itemDef instanceof PrismPropertyDefinition) {

            PrismPropertyDefinition def = (PrismPropertyDefinition) itemDef;
            if (def.isIgnored() || skipProperty(def)) {
              continue;
            }
            if (!showInheritedObjectAttributes
                && INHERITED_OBJECT_ATTRIBUTES.contains(def.getName())) {
              continue;
            }

            // capability handling for activation properties
            if (isShadowActivation() && !hasCapability(def)) {
              continue;
            }

            if (isShadowAssociation()) {
              continue;
            }

            PrismProperty property = container.findProperty(def.getName());
            boolean propertyIsReadOnly;
            // decision is based on parent object status, not this
            // container's one (because container can be added also
            // to an existing object)
            if (objectWrapper.getStatus() == ContainerStatus.MODIFYING) {

              propertyIsReadOnly = !def.canModify();
            } else {
              propertyIsReadOnly = !def.canAdd();
            }
            if (property == null) {
              properties.add(
                  new PropertyWrapper(
                      this, def.instantiate(), propertyIsReadOnly, ValueStatus.ADDED));
            } else {
              properties.add(
                  new PropertyWrapper(this, property, propertyIsReadOnly, ValueStatus.NOT_CHANGED));
            }
          } else if (itemDef instanceof PrismReferenceDefinition) {
            PrismReferenceDefinition def = (PrismReferenceDefinition) itemDef;

            if (INHERITED_OBJECT_ATTRIBUTES.contains(def.getName())) {
              continue;
            }

            PrismReference reference = container.findReference(def.getName());
            boolean propertyIsReadOnly;
            // decision is based on parent object status, not this
            // container's one (because container can be added also
            // to an existing object)
            if (objectWrapper.getStatus() == ContainerStatus.MODIFYING) {

              propertyIsReadOnly = !def.canModify();
            } else {
              propertyIsReadOnly = !def.canAdd();
            }
            if (reference == null) {
              properties.add(
                  new ReferenceWrapper(
                      this, def.instantiate(), propertyIsReadOnly, ValueStatus.ADDED));
            } else {
              properties.add(
                  new ReferenceWrapper(
                      this, reference, propertyIsReadOnly, ValueStatus.NOT_CHANGED));
            }
          }
        }
      }
    }

    Collections.sort(properties, new ItemWrapperComparator());

    result.recomputeStatus();

    return properties;
  }