public ObjectPolicyConfigurationTypeDto preparePolicyConfig() {
    ObjectPolicyConfigurationTypeDto newConfig = new ObjectPolicyConfigurationTypeDto();

    newConfig.setConstraints(propertyConstraintsList);
    newConfig.setType(type);

    ObjectReferenceType ref = new ObjectReferenceType();
    if (templateRef != null) {
      ref.setOid(templateRef.getOid());
      ref.setType(ObjectTemplateType.COMPLEX_TYPE);
    }

    newConfig.setTemplateRef(ref);

    return newConfig;
  }
  private List<ObjectReferenceType> createResourceList() {
    resourceMap.clear();
    OperationResult result = new OperationResult(OPERATION_LOAD_RESOURCES);
    Task task = getPageBase().createSimpleTask(OPERATION_LOAD_RESOURCES);
    List<PrismObject<ResourceType>> resources = null;
    List<ObjectReferenceType> references = new ArrayList<>();

    try {
      resources =
          getPageBase()
              .getModelService()
              .searchObjects(ResourceType.class, new ObjectQuery(), null, task, result);
      result.recomputeStatus();
    } catch (Exception e) {
      result.recordFatalError("Couldn't get resource list.", e);
      LoggingUtils.logException(LOGGER, "Couldn't get resource list.", e);
    }

    // TODO - show error somehow
    // if(!result.isSuccess()){
    //    getPageBase().showResult(result);
    // }

    if (resources != null) {
      ObjectReferenceType ref;
      for (PrismObject<ResourceType> r : resources) {
        resourceMap.put(r.getOid(), WebMiscUtil.getName(r));
        ref = new ObjectReferenceType();
        ref.setType(ResourceType.COMPLEX_TYPE);
        ref.setOid(r.getOid());
        references.add(ref);
      }
    }

    return references;
  }
Beispiel #3
0
 private ExpressionVariables processInnerVariables(
     ExpressionVariables variables, String contextDescription, Task task, OperationResult result)
     throws SchemaException, ObjectNotFoundException {
   if (expressionType == null
       || expressionType.getVariable() == null
       || expressionType.getVariable().isEmpty()) {
     // shortcut
     return variables;
   }
   ExpressionVariables newVariables = new ExpressionVariables();
   for (Entry<QName, Object> entry : variables.entrySet()) {
     newVariables.addVariableDefinition(entry.getKey(), entry.getValue());
   }
   for (ExpressionVariableDefinitionType variableDefType : expressionType.getVariable()) {
     QName varName = variableDefType.getName();
     if (varName == null) {
       throw new SchemaException("No variable name in expression in " + contextDescription);
     }
     if (variableDefType.getObjectRef() != null) {
       ObjectReferenceType ref = variableDefType.getObjectRef();
       ref.setType(prismContext.getSchemaRegistry().qualifyTypeName(ref.getType()));
       ObjectType varObject =
           objectResolver.resolve(
               ref,
               ObjectType.class,
               null,
               "variable " + varName + " in " + contextDescription,
               task,
               result);
       newVariables.addVariableDefinition(varName, varObject);
     } else if (variableDefType.getValue() != null) {
       // Only string is supported now
       Object valueObject = variableDefType.getValue();
       if (valueObject instanceof String) {
         newVariables.addVariableDefinition(varName, valueObject);
       } else if (valueObject instanceof Element) {
         newVariables.addVariableDefinition(varName, ((Element) valueObject).getTextContent());
       } else if (valueObject instanceof RawType) {
         newVariables.addVariableDefinition(
             varName, ((RawType) valueObject).getParsedValue(null, varName));
       } else {
         throw new SchemaException(
             "Unexpected type "
                 + valueObject.getClass()
                 + " in variable definition "
                 + varName
                 + " in "
                 + contextDescription);
       }
     } else if (variableDefType.getPath() != null) {
       ItemPath itemPath = variableDefType.getPath().getItemPath();
       Object resolvedValue =
           ExpressionUtil.resolvePath(
               itemPath, variables, null, objectResolver, contextDescription, task, result);
       newVariables.addVariableDefinition(varName, resolvedValue);
     } else {
       throw new SchemaException("No value for variable " + varName + " in " + contextDescription);
     }
   }
   return newVariables;
 }