Example #1
0
  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());
  }
Example #2
0
  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;
  }
Example #3
0
 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;
 }
Example #4
0
  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;
  }
Example #5
0
  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;
 }
Example #7
0
  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;
  }
Example #8
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;
      }
    }
  }