private void removeValue(AjaxRequestTarget target) {
ValueWrapper wrapper = model.getObject();
ItemWrapper propertyWrapper = wrapper.getItem();
List<ValueWrapper> values = propertyWrapper.getValues();
Component inputPanel = this.get(ID_VALUE_CONTAINER).get(ID_INPUT);
switch (wrapper.getStatus()) {
case ADDED:
values.remove(wrapper);
break;
case DELETED:
error("Couldn't delete already deleted item: " + wrapper.toString());
target.add(((PageBase) getPage()).getFeedbackPanel());
case NOT_CHANGED:
wrapper.setStatus(ValueStatus.DELETED);
break;
}
int count = countUsableValues(propertyWrapper);
if (count == 0 && !hasEmptyPlaceholder(propertyWrapper)) {
if (inputPanel instanceof ValueChoosePanel) {
values.add(
new ValueWrapper(propertyWrapper, new PrismReferenceValue(null), ValueStatus.ADDED));
} else {
values.add(
new ValueWrapper(propertyWrapper, new PrismPropertyValue(null), ValueStatus.ADDED));
}
}
ListView parent = findParent(ListView.class);
target.add(parent.getParent());
}
private boolean hasEmptyPlaceholder(ItemWrapper property) {
for (ValueWrapper value : property.getValues()) {
value.normalize(property.getItemDefinition().getPrismContext());
if (ValueStatus.ADDED.equals(value.getStatus()) && !value.hasValueChanged()) {
return true;
}
}
return false;
}
private int countNonDeletedValues(ItemWrapper property) {
int count = 0;
for (ValueWrapper value : property.getValues()) {
value.normalize(property.getItemDefinition().getPrismContext());
if (ValueStatus.DELETED.equals(value.getStatus())) {
continue;
}
count++;
}
return count;
}
private List<ValueWrapper> getUsableValues(ItemWrapper property) {
List<ValueWrapper> values = new ArrayList<>();
for (ValueWrapper value : property.getValues()) {
value.normalize(property.getItemDefinition().getPrismContext());
if (ValueStatus.DELETED.equals(value.getStatus())) {
continue;
}
values.add(value);
}
return values;
}
private int countUsableValues(ItemWrapper property) {
int count = 0;
for (ValueWrapper value : property.getValues()) {
value.normalize(property.getItemDefinition().getPrismContext());
if (ValueStatus.DELETED.equals(value.getStatus())) {
continue;
}
if (ValueStatus.ADDED.equals(value.getStatus()) && !value.hasValueChanged()) {
continue;
}
count++;
}
return count;
}
private boolean showEmpty(ItemWrapper item) {
ObjectWrapper objectWrapper = getObject();
List<ValueWrapper> valueWrappers = item.getValues();
boolean isEmpty;
if (valueWrappers == null) {
isEmpty = true;
} else {
isEmpty = valueWrappers.isEmpty();
}
if (!isEmpty && valueWrappers.size() == 1) {
ValueWrapper value = valueWrappers.get(0);
if (ValueStatus.ADDED.equals(value.getStatus())) {
isEmpty = true;
}
}
return objectWrapper.isShowEmpty() || !isEmpty;
}
private ObjectDelta createAddingObjectDelta() throws SchemaException {
PrismObject object = this.object.clone();
List<ContainerWrapper> containers = getContainers();
// sort containers by path size
Collections.sort(containers, new PathSizeComparator());
for (ContainerWrapper containerWrapper : getContainers()) {
if (containerWrapper.getItemDefinition().getName().equals(ShadowType.F_ASSOCIATION)) {
PrismContainer associationContainer =
object.findOrCreateContainer(ShadowType.F_ASSOCIATION);
List<AssociationWrapper> associationItemWrappers =
(List<AssociationWrapper>) containerWrapper.getItems();
for (AssociationWrapper associationItemWrapper : associationItemWrappers) {
List<ValueWrapper> assocValueWrappers = associationItemWrapper.getValues();
for (ValueWrapper assocValueWrapper : assocValueWrappers) {
PrismContainerValue<ShadowAssociationType> assocValue =
(PrismContainerValue<ShadowAssociationType>) assocValueWrapper.getValue();
associationContainer.add(assocValue.clone());
}
}
continue;
}
if (!containerWrapper.hasChanged()) {
continue;
}
PrismContainer container = containerWrapper.getItem();
ItemPath path = containerWrapper.getPath();
if (containerWrapper.getPath() != null) {
container = container.clone();
if (path.size() > 1) {
ItemPath parentPath = path.allExceptLast();
PrismContainer parent = object.findOrCreateContainer(parentPath);
parent.add(container);
} else {
PrismContainer existing = object.findContainer(container.getElementName());
if (existing == null) {
object.add(container);
} else {
continue;
}
}
} else {
container = object;
}
for (ItemWrapper propertyWrapper : (List<ItemWrapper>) containerWrapper.getItems()) {
if (!propertyWrapper.hasChanged()) {
continue;
}
Item property = propertyWrapper.getItem().clone();
if (container.findProperty(property.getElementName()) != null) {
continue;
}
for (ValueWrapper valueWrapper : propertyWrapper.getValues()) {
valueWrapper.normalize(object.getPrismContext());
if (!valueWrapper.hasValueChanged()
|| ValueStatus.DELETED.equals(valueWrapper.getStatus())) {
continue;
}
if (property.hasRealValue(valueWrapper.getValue())) {
continue;
}
PrismValue cloned = clone(valueWrapper.getValue());
if (cloned != null) {
property.add(cloned);
}
}
if (!property.isEmpty()) {
container.add(property);
}
}
}
// cleanup empty containers
cleanupEmptyContainers(object);
ObjectDelta delta = ObjectDelta.createAddDelta(object);
// returning container to previous order
Collections.sort(containers, new ItemWrapperComparator());
if (InternalsConfig.consistencyChecks) {
delta.checkConsistence(true, true, true, ConsistencyCheckScope.THOROUGH);
}
return delta;
}
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;
}
}
}