示例#1
0
  private boolean isAddButtonVisible() {
    ValueWrapper valueWrapper = model.getObject();

    if (valueWrapper.isReadonly()) {
      return false;
    }

    ItemWrapper propertyWrapper = valueWrapper.getItem();
    Item property = propertyWrapper.getItem();

    ItemDefinition definition = property.getDefinition();
    int max = definition.getMaxOccurs();
    List<ValueWrapper> usableValues = getUsableValues(propertyWrapper);
    if (usableValues.indexOf(valueWrapper) != usableValues.size() - 1) {
      return false;
    }

    if (max == -1) {
      return true;
    }

    if (countNonDeletedValues(propertyWrapper) >= max) {
      return false;
    }

    return isAccessible(definition, propertyWrapper.getContainer().getObject().getStatus());
  }
  private <T> QName determineRerturnType(
      Class<T> type,
      ScriptExpressionEvaluatorType expressionType,
      ItemDefinition outputDefinition,
      ScriptExpressionReturnTypeType suggestedReturnType)
      throws ExpressionEvaluationException {

    if (expressionType.getReturnType() == ScriptExpressionReturnTypeType.LIST
        || suggestedReturnType == ScriptExpressionReturnTypeType.LIST) {
      return XPathConstants.NODESET;
    }

    if (expressionType.getReturnType() == ScriptExpressionReturnTypeType.SCALAR) {
      return toXPathReturnType(outputDefinition.getTypeName());
    }

    if (suggestedReturnType == ScriptExpressionReturnTypeType.LIST) {
      return XPathConstants.NODESET;
    }

    if (suggestedReturnType == ScriptExpressionReturnTypeType.SCALAR) {
      return toXPathReturnType(outputDefinition.getTypeName());
    }

    if (outputDefinition.isMultiValue()) {
      return XPathConstants.NODESET;
    } else {
      return toXPathReturnType(outputDefinition.getTypeName());
    }
  }
示例#3
0
  public <IV extends PrismValue, ID extends ItemDefinition> XNode serializeItem(
      Item<IV, ID> item, SerializationContext ctx) throws SchemaException {
    ListXNode xlist = new ListXNode();
    List<IV> values = item.getValues();
    ItemDefinition definition = item.getDefinition();

    for (IV val : values) {
      XNode xsubnode = serializeItemValue(val, definition, ctx);
      xlist.add(xsubnode);
    }

    boolean asList;
    if (definition != null) {
      asList = definition.isMultiValue();
    } else {
      asList = values.size() > 1;
    }

    if (asList) {
      return xlist;
    } else {
      if (xlist.isEmpty()) {
        return null;
      } else {
        return xlist.iterator().next();
      }
    }
  }
示例#4
0
  private boolean isAddButtonVisible() {
    Component inputPanel = this.get(ID_VALUE_CONTAINER).get(ID_INPUT);
    ValueWrapper valueWrapper = valueWrapperModel.getObject();

    if (valueWrapper.isReadonly()) {
      return false;
    }

    ItemWrapper propertyWrapper = valueWrapper.getItem();
    Item property = propertyWrapper.getItem();

    ItemDefinition definition = property.getDefinition();
    int max = definition.getMaxOccurs();
    List<ValueWrapper> usableValues = getUsableValues(propertyWrapper);
    if (usableValues.indexOf(valueWrapper) != usableValues.size() - 1) {
      return false;
    }

    if (max == -1) {
      return true;
    }

    if (countNonDeletedValues(propertyWrapper) >= max) {
      return false;
    }

    if (propertyWrapper.getContainer() == null) {
      return true; // TODO
    }
    return isAccessible(definition, getContainerStatus(propertyWrapper));
  }
示例#5
0
  private boolean isRemoveButtonVisible() {
    ValueWrapper valueWrapper = valueWrapperModel.getObject();

    if (valueWrapper.isReadonly()) {
      return false;
    }
    Component inputPanel = this.get(ID_VALUE_CONTAINER).get(ID_INPUT);
    if (inputPanel instanceof ValueChoosePanel
        || inputPanel instanceof AssociationValueChoicePanel) {
      return true;
    }

    ItemWrapper propertyWrapper = valueWrapper.getItem();
    ItemDefinition definition = propertyWrapper.getItem().getDefinition();
    int min = definition.getMinOccurs();

    int count = countNonDeletedValues(propertyWrapper);
    if (count <= 1 || count <= min) {
      return false;
    }

    if (propertyWrapper.getContainer() == null) {
      return true; // TODO
    }

    return isAccessible(definition, getContainerStatus(propertyWrapper));
  }
示例#6
0
 // element name may be null (it is then derived from the definition, if the definition exists)
 private RootXNode serializeItemValueAsRootInternal(PrismValue value, QName elementName)
     throws SchemaException {
   ItemDefinition definition =
       value.getParent().getDefinition(); // the definition may be null here
   XNode valueNode = serializeItemValue(value, definition);
   if (elementName == null) {
     if (definition == null) {
       throw new IllegalStateException(
           "The name of element to be serialized couldn't be determined, as there's no definition");
     }
     elementName = definition.getName();
   }
   return new RootXNode(elementName, valueNode);
 }
示例#7
0
 // definition may be null
 private <V extends PrismValue> XNode serializeItemValue(
     PrismValue itemValue, ItemDefinition definition, SerializationContext ctx)
     throws SchemaException {
   XNode xnode;
   if (definition == null) {
     if (itemValue.getParent() != null) {
       definition = itemValue.getParent().getDefinition();
     }
   }
   if (beanConverter.getPrismContext() == null) {
     throw new IllegalStateException("No prismContext in beanConverter!");
   }
   if (definition == null && itemValue instanceof PrismPropertyValue) {
     return serializePropertyRawValue((PrismPropertyValue<?>) itemValue);
   }
   if (itemValue instanceof PrismReferenceValue) {
     xnode =
         serializeReferenceValue(
             (PrismReferenceValue) itemValue, (PrismReferenceDefinition) definition, ctx);
   } else if (itemValue instanceof PrismPropertyValue<?>) {
     xnode =
         serializePropertyValue(
             (PrismPropertyValue<?>) itemValue, (PrismPropertyDefinition) definition);
   } else if (itemValue instanceof PrismContainerValue<?>) {
     xnode =
         serializeContainerValue(
             (PrismContainerValue<?>) itemValue, (PrismContainerDefinition) definition, ctx);
   } else {
     throw new IllegalArgumentException("Unsupported value type " + itemValue.getClass());
   }
   if (definition != null && definition.isDynamic()) {
     xnode.setExplicitTypeDeclaration(true);
   }
   return xnode;
 }
示例#8
0
 @Override
 public int hashCode() {
   int result = fullPath != null ? fullPath.hashCode() : 0;
   result = 31 * result + (definition != null ? definition.hashCode() : 0);
   result = 31 * result + (filter != null ? filter.hashCode() : 0);
   return result;
 }
示例#9
0
  private boolean isAccessible(ItemDefinition def, ContainerStatus status) {
    switch (status) {
      case ADDING:
        if (!def.canAdd()) {
          return false;
        }
        break;
      case MODIFYING:
        if (!def.canModify()) {
          return false;
        }
        break;
    }

    return true;
  }
示例#10
0
 @Override
 public String debugDump(int indent) {
   StringBuilder sb = new StringBuilder();
   DebugUtil.indentDebugDump(sb, indent);
   sb.append(getDebugName());
   sb.append(": ").append(PrettyPrinter.prettyPrint(getName())).append("\n");
   DebugUtil.debugDumpWithLabel(sb, "displayName", displayName, indent + 1);
   sb.append("\n");
   DebugUtil.debugDumpWithLabel(
       sb, "status", status == null ? null : status.toString(), indent + 1);
   sb.append("\n");
   DebugUtil.debugDumpWithLabel(sb, "readonly", readonly, indent + 1);
   sb.append("\n");
   DebugUtil.debugDumpWithLabel(
       sb,
       "itemDefinition",
       itemDefinition == null ? null : itemDefinition.toString(),
       indent + 1);
   sb.append("\n");
   DebugUtil.debugDumpWithLabel(
       sb, "property", property == null ? null : property.toString(), indent + 1);
   sb.append("\n");
   DebugUtil.debugDumpLabel(sb, "values", indent + 1);
   sb.append("\n");
   DebugUtil.debugDump(sb, values, indent + 2, false);
   return sb.toString();
 }
示例#11
0
  public static <T> String toRepo(
      ItemDefinition parentDefinition, QName itemName, T value, PrismContext prismContext)
      throws SchemaException, JAXBException {
    if (value == null) {
      return null;
    }

    if (value instanceof Objectable) {
      return prismContext.serializeObjectToString(
          ((Objectable) value).asPrismObject(), PrismContext.LANG_XML);
    }

    ItemDefinition definition = null;
    if (parentDefinition instanceof PrismContainerDefinition) {
      definition = ((PrismContainerDefinition) parentDefinition).findItemDefinition(itemName);
      if (definition == null) {
        definition = parentDefinition;
      }
    } else {
      definition = parentDefinition;
    }

    return ValueSerializationUtil.serializeValue(
        value,
        definition,
        itemName,
        parentDefinition.getName(),
        prismContext,
        PrismContext.LANG_XML);
  }
示例#12
0
 public void revive(PrismContext prismContext) throws SchemaException {
   if (property != null) {
     property.revive(prismContext);
   }
   if (itemDefinition != null) {
     itemDefinition.revive(prismContext);
   }
 }
示例#13
0
  private <C extends Containerable> void serializeContainerValue(
      MapXNode xmap,
      PrismContainerValue<C> containerVal,
      PrismContainerDefinition<C> containerDefinition,
      SerializationContext ctx)
      throws SchemaException {
    Long id = containerVal.getId();
    if (id != null) {
      xmap.put(XNode.KEY_CONTAINER_ID, createPrimitiveXNodeAttr(id, DOMUtil.XSD_LONG));
    }
    if (containerVal.getConcreteType() != null) {
      xmap.setTypeQName(containerVal.getConcreteType());
      xmap.setExplicitTypeDeclaration(true);
    }

    Collection<QName> serializedItems = new ArrayList<>();
    if (containerDefinition != null) {
      // We have to serialize in the definition order. Some data formats (XML) are
      // ordering-sensitive. We need to keep that ordering otherwise the resulting
      // document won't pass schema validation
      for (ItemDefinition itemDef : containerDefinition.getDefinitions()) {
        QName elementName = itemDef.getName();
        Item<?, ?> item = containerVal.findItem(elementName);
        if (item != null) {
          XNode xsubnode = serializeItem(item, ctx);
          xmap.put(elementName, xsubnode);
          serializedItems.add(elementName);
        }
      }
    }
    // There are some cases when we do not have list of all elements in a container.
    // E.g. in run-time schema. Therefore we must also iterate over items and not just item
    // definitions.
    if (containerVal.getItems() != null) {
      for (Item<?, ?> item : containerVal.getItems()) {
        QName elementName = item.getElementName();
        if (serializedItems.contains(elementName)) {
          continue;
        }
        XNode xsubnode = serializeItem(item, ctx);
        xmap.put(elementName, xsubnode);
      }
    }
  }
示例#14
0
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof ExistsFilter)) return false;

    ExistsFilter that = (ExistsFilter) o;

    if (fullPath != null ? !fullPath.equals(that.fullPath) : that.fullPath != null) return false;
    if (definition != null ? !definition.equals(that.definition) : that.definition != null)
      return false;
    return !(filter != null ? !filter.equals(that.filter) : that.filter != null);
  }
示例#15
0
  public ValueWrapper createAddedValue() {
    ItemDefinition definition = property.getDefinition();

    ValueWrapper wrapper;
    if (SchemaConstants.T_POLY_STRING_TYPE.equals(definition.getTypeName())) {
      wrapper =
          new ValueWrapper(
              this,
              new PrismPropertyValue(new PolyString("")),
              new PrismPropertyValue(new PolyString("")),
              ValueStatus.ADDED);
    } else if (isUser() && isThisPropertyActivationEnabled()) {
      wrapper =
          new ValueWrapper(
              this, new PrismPropertyValue(null), new PrismPropertyValue(null), ValueStatus.ADDED);
    } else {
      wrapper = new ValueWrapper(this, new PrismPropertyValue(null), ValueStatus.ADDED);
    }

    return wrapper;
  }
  boolean isItemVisible(ItemWrapper item) {
    ItemDefinition def = item.getItemDefinition();
    if (def.isIgnored() || def.isOperational()) {
      return false;
    }

    if (def instanceof PrismPropertyDefinition && skipProperty((PrismPropertyDefinition) def)) {
      return false;
    }

    // we decide not according to status of this container, but according to
    // the status of the whole object
    if (objectWrapper.getStatus() == ContainerStatus.ADDING) {
      return def.canAdd();
    }

    // otherwise, object.getStatus() is MODIFYING

    if (def.canModify()) {
      return showEmpty(item);
    } else {
      if (def.canRead()) {
        return showEmpty(item);
      }
      return false;
    }
  }
  public static <T> String serializeValue(
      T value,
      ItemDefinition def,
      QName itemName,
      QName parentName,
      PrismContext prismContext,
      String language)
      throws SchemaException {
    //		System.out.println("value serialization");
    if (value == null) {
      return null;
    }

    XNodeSerializer serializer = prismContext.getXnodeProcessor().createSerializer();

    if (value instanceof List) {
      List<T> values = (List<T>) value;
      if (values.isEmpty()) {
        return null;
      }

      if (def instanceof PrismPropertyDefinition) {
        PrismProperty prop = (PrismProperty) def.instantiate(itemName);
        for (T val : values) {
          PrismPropertyValue<T> pValue = new PrismPropertyValue<T>(val);
          prop.add(pValue);
        }

        XNode node = serializer.serializeItem(prop);
        if (node instanceof ListXNode) {
          ListXNode xList = (ListXNode) node;
          if (xList.size() == 1) {
            XNode sub = xList.iterator().next();
            if (!(sub instanceof MapXNode)) {
              throw new IllegalArgumentException("must be a map");
            }

            String s = prismContext.getParserDom().serializeToString(sub, parentName);
            //						System.out.println("serialized: " + s);
            return s;

          } else {
            MapXNode xmap = new MapXNode();
            xmap.put(itemName, xList);
            String s = prismContext.getParserDom().serializeToString(xmap, parentName);
            //						System.out.println("serialized: " + s);
            return s;
            //						throw new IllegalArgumentException("Check your data.");
          }

          //					MapXNode xmap = xList.new MapXNode();
          //					xmap.put(def.getName(), xList);

        }
        String s = prismContext.getParserDom().serializeToString(node, def.getName());
        //				System.out.println("serialized: " + s);
        return s;
      } else if (def instanceof PrismContainerDefinition) {
        PrismContainer pc = (PrismContainer) def.instantiate();
        for (T val : values) {
          //					PrismContainerValue pcVal = new PrismContainerValue<Containerable>((Containerable)
          // val);
          PrismContainerValue pcVal = ((Containerable) val).asPrismContainerValue();
          pc.add(pcVal.clone());
        }
        XNode node = serializer.serializeItem(pc);
        if (node instanceof ListXNode) {
          ListXNode xList = (ListXNode) node;
          MapXNode xmap = new MapXNode();
          xmap.put(def.getName(), xList);
          String s = prismContext.getParserDom().serializeToString(xmap, parentName);
          //					System.out.println("serialized: " + s);
          return s;
        }
        String s = prismContext.getParserDom().serializeToString(node, def.getName());
        //				System.out.println("serialized: " + s);
        return s;
      }
    }

    PrismValue pVal = null;

    if (value instanceof Containerable) {
      pVal = ((Containerable) value).asPrismContainerValue();
    } else if (value instanceof Referencable) {
      pVal = ((Referencable) value).asReferenceValue();
    } else {
      pVal = new PrismPropertyValue<T>(value);
    }

    //		Class clazz = prismContext.getSchemaRegistry().determineCompileTimeClass(itemName);
    //		PrismContainerDefinition def =
    // prismContext.getSchemaRegistry().determineDefinitionFromClass(clazz);
    //
    //		ItemDefinition def =
    // prismContext.getSchemaRegistry().findItemDefinitionByElementName(itemName);

    //		QName itemName = null;
    if (def != null) {
      itemName = def.getName();
    }

    XNode node = serializer.serializeItemValue(pVal, def);
    String s = prismContext.getParserDom().serializeToString(node, itemName);
    //		System.out.println("serialized: " + s);
    return s;
    //		throw new UnsupportedOperationException("need to be implemented");
  }
  @Override
  public <T, V extends PrismValue> List<V> evaluate(
      ScriptExpressionEvaluatorType expressionType,
      ExpressionVariables variables,
      ItemDefinition outputDefinition,
      ScriptExpressionReturnTypeType suggestedReturnType,
      ObjectResolver objectResolver,
      Collection<FunctionLibrary> functions,
      String contextDescription,
      Task task,
      OperationResult result)
      throws ExpressionEvaluationException, ObjectNotFoundException, ExpressionSyntaxException {

    String codeString = expressionType.getCode();
    if (codeString == null) {
      throw new ExpressionEvaluationException("No script code in " + contextDescription);
    }

    Class<T> type = null;

    if (outputDefinition != null) {
      QName xsdReturnType = outputDefinition.getTypeName();
      type = XsdTypeMapper.toJavaType(xsdReturnType); // may return null if unknown
    }
    if (type == null) {
      type =
          (Class<T>)
              Element
                  .class; // actually, if outputDefinition is null, the return value is of no
                          // interest for us
    }

    QName returnType =
        determineRerturnType(type, expressionType, outputDefinition, suggestedReturnType);

    Object evaluatedExpression =
        evaluate(
            returnType,
            codeString,
            variables,
            objectResolver,
            functions,
            contextDescription,
            result);

    List<V> propertyValues;

    boolean scalar = !outputDefinition.isMultiValue();
    if (expressionType.getReturnType() != null) {
      scalar = isScalar(expressionType.getReturnType());
    } else if (suggestedReturnType != null) {
      scalar = isScalar(suggestedReturnType);
    }

    if (scalar) {
      if (evaluatedExpression instanceof NodeList) {
        NodeList evaluatedExpressionNodeList = (NodeList) evaluatedExpression;
        if (evaluatedExpressionNodeList.getLength() > 1) {
          throw new ExpressionEvaluationException(
              "Expected scalar expression result but got a list result with "
                  + evaluatedExpressionNodeList.getLength()
                  + " elements in "
                  + contextDescription);
        }
        if (evaluatedExpressionNodeList.getLength() == 0) {
          evaluatedExpression = null;
        } else {
          evaluatedExpression = evaluatedExpressionNodeList.item(0);
        }
      }
      propertyValues = new ArrayList<V>(1);
      V pval = convertScalar(type, returnType, evaluatedExpression, contextDescription);
      if (pval instanceof PrismPropertyValue
          && !isNothing(((PrismPropertyValue<T>) pval).getValue())) {
        propertyValues.add(pval);
      }
    } else {
      if (!(evaluatedExpression instanceof NodeList)) {
        throw new IllegalStateException(
            "The expression "
                + contextDescription
                + " resulted in "
                + evaluatedExpression.getClass().getName()
                + " while exprecting NodeList in "
                + contextDescription);
      }
      propertyValues = convertList(type, (NodeList) evaluatedExpression, contextDescription);
    }

    return (List<V>) PrismValue.cloneCollection(propertyValues);
  }
示例#19
0
  private List<ContainerWrapper> createContainerWrapper(
      PrismContainer parent, ItemPath path, PageBase pageBase) {

    PrismContainerDefinition definition = parent.getDefinition();
    List<ContainerWrapper> wrappers = new ArrayList<ContainerWrapper>();

    List<ItemPathSegment> segments = new ArrayList<ItemPathSegment>();
    if (path != null) {
      segments.addAll(path.getSegments());
    }
    ItemPath parentPath = new ItemPath(segments);
    for (ItemDefinition def : (Collection<ItemDefinition>) definition.getDefinitions()) {
      if (!(def instanceof PrismContainerDefinition)) {
        continue;
      }
      if (ObjectSpecificationType.COMPLEX_TYPE.equals(def.getTypeName())) {
        continue; // TEMPORARY FIX
      }
      if (TriggerType.COMPLEX_TYPE.equals(def.getTypeName())) {
        continue; // TEMPORARY FIX TODO: remove after getEditSchema
        // (authorization) will be fixed.
      }
      if (ApprovalSchemaType.COMPLEX_TYPE.equals(def.getTypeName())) {
        continue;
      }

      LOGGER.trace("ObjectWrapper.createContainerWrapper processing definition: {}", def);

      PrismContainerDefinition containerDef = (PrismContainerDefinition) def;
      if (!showAssignments && AssignmentType.COMPLEX_TYPE.equals(containerDef.getTypeName())) {
        continue;
      }
      if (!showInheritedObjectAttributes) {
        boolean result = INHERITED_OBJECT_SUBCONTAINERS.contains(containerDef.getName());
        LOGGER.info("checking " + containerDef.getName() + ", result = " + result);
        if (result) {
          continue;
        }
      }

      ItemPath newPath = createPropertyPath(parentPath, containerDef.getName());

      // [med]
      // The following code fails to work when parent is multivalued or
      // potentially multivalued.
      // Therefore (as a brutal hack), for multivalued parents we simply
      // skip it.
      if (parent.size() <= 1) {

        // the same check as in getValue() implementation
        boolean isMultiValued =
            parent.getDefinition() != null
                && !parent.getDefinition().isDynamic()
                && !parent.getDefinition().isSingleValue();
        if (!isMultiValued) {
          PrismContainer prismContainer = parent.findContainer(def.getName());

          ContainerWrapper container;
          if (prismContainer != null) {
            container =
                new ContainerWrapper(
                    this, prismContainer, ContainerStatus.MODIFYING, newPath, pageBase);
          } else {
            prismContainer = containerDef.instantiate();
            container =
                new ContainerWrapper(
                    this, prismContainer, ContainerStatus.ADDING, newPath, pageBase);
          }
          addSubresult(container.getResult());
          wrappers.add(container);

          if (!AssignmentType.COMPLEX_TYPE.equals(containerDef.getTypeName())
              || !ShadowType.F_ASSOCIATION.equals(parent.getElementName())) { // do
            // not
            // show
            // internals
            // of
            // Assignments
            // (e.g.
            // activation)
            wrappers.addAll(createContainerWrapper(prismContainer, newPath, pageBase));
          }
        }
      }
    }

    return wrappers;
  }
示例#20
0
 private ItemDelta computePropertyDeltas(PropertyWrapper propertyWrapper, ItemPath containerPath) {
   ItemDefinition itemDef = propertyWrapper.getItem().getDefinition();
   ItemDelta pDelta = itemDef.createEmptyDelta(containerPath.subPath(itemDef.getName()));
   addItemDelta(propertyWrapper, pDelta, itemDef, containerPath);
   return pDelta;
 }
示例#21
0
  private void addItemDelta(
      ItemWrapper itemWrapper,
      ItemDelta pDelta,
      ItemDefinition propertyDef,
      ItemPath containerPath) {
    for (ValueWrapper valueWrapper : itemWrapper.getValues()) {
      valueWrapper.normalize(propertyDef.getPrismContext());
      ValueStatus valueStatus = valueWrapper.getStatus();
      if (!valueWrapper.hasValueChanged()
          && (ValueStatus.NOT_CHANGED.equals(valueStatus)
              || ValueStatus.ADDED.equals(valueStatus))) {
        continue;
      }

      // TODO: need to check if the resource has defined
      // capabilities
      // todo this is bad hack because now we have not tri-state
      // checkbox
      if (SchemaConstants.PATH_ACTIVATION.equivalent(containerPath)) {

        if (object.asObjectable() instanceof ShadowType
            && (((ShadowType) object.asObjectable()).getActivation() == null
                || ((ShadowType) object.asObjectable()).getActivation().getAdministrativeStatus()
                    == null)) {

          if (!hasResourceCapability(
              ((ShadowType) object.asObjectable()).getResource(), ActivationCapabilityType.class)) {
            continue;
          }
        }
      }

      PrismValue newValCloned = clone(valueWrapper.getValue());
      PrismValue oldValCloned = clone(valueWrapper.getOldValue());
      switch (valueWrapper.getStatus()) {
        case ADDED:
          if (newValCloned != null) {
            if (SchemaConstants.PATH_PASSWORD.equivalent(containerPath)) {
              // password change will always look like
              // add,
              // therefore we push replace
              pDelta.setValuesToReplace(Arrays.asList(newValCloned));
            } else if (propertyDef.isSingleValue()) {
              // values for single-valued properties
              // should be pushed via replace
              // in order to prevent problems e.g. with
              // summarizing deltas for
              // unreachable resources
              pDelta.setValueToReplace(newValCloned);
            } else {
              pDelta.addValueToAdd(newValCloned);
            }
          }
          break;
        case DELETED:
          if (newValCloned != null) {
            pDelta.addValueToDelete(newValCloned);
          }
          if (oldValCloned != null) {
            pDelta.addValueToDelete(oldValCloned);
          }
          break;
        case NOT_CHANGED:
          // this is modify...
          if (propertyDef.isSingleValue()) {
            // newValCloned.isEmpty()
            if (newValCloned != null && !newValCloned.isEmpty()) {
              pDelta.setValuesToReplace(Arrays.asList(newValCloned));
            } else {
              if (oldValCloned != null) {
                pDelta.addValueToDelete(oldValCloned);
              }
            }
          } else {
            if (newValCloned != null && !newValCloned.isEmpty()) {
              pDelta.addValueToAdd(newValCloned);
            }
            if (oldValCloned != null) {
              pDelta.addValueToDelete(oldValCloned);
            }
          }
          break;
      }
    }
  }