Best code snippets using com.evolveum.midpoint.prism.query.ExistsFilter(Showing top 15 results out of 315)

@SuppressWarnings("CloneDoesntCallSuperClone")
@Override
public ObjectFilter clone() {
  ObjectFilter f = filter != null ? filter.clone() : null;
  return new ExistsFilter(fullPath, definition, f);
}

public ExistsFilter(@NotNull ItemPath fullPath, ItemDefinition definition, ObjectFilter filter) {
  this.fullPath = fullPath;
  this.definition = definition;
  this.filter = filter;
  checkConsistence(true);
}

public static <C extends Containerable> ExistsFilter createExists(ItemPath itemPath, PrismContainerDefinition<C> containerDef,
                                 ObjectFilter filter) throws SchemaException {
  ItemDefinition itemDefinition = FilterUtils.findItemDefinition(itemPath, containerDef);
  return new ExistsFilter(itemPath, itemDefinition, filter);
}

private static MapXNode serializeExistsFilter(ExistsFilter filter, PrismSerializer<RootXNode> xnodeSerializer) throws SchemaException{
  MapXNode content = new MapXNode();
  serializePath(content, filter.getFullPath(), filter);
  if (filter.getFilter() != null){
    content.put(ELEMENT_FILTER, serializeFilter(filter.getFilter(), xnodeSerializer));
  }
  return createFilter(CLAUSE_EXISTS, content);
}

public ExistsRestriction(InterpretationContext context, ExistsFilter filter, JpaEntityDefinition baseEntityDefinition,
             Restriction parent) {
  super(context, filter, filter.getFullPath(), null, baseEntityDefinition, parent);
}

@Override
public String debugDump() {
  return debugDump(0);
}

private static ExistsFilter parseExistsFilter(MapXNode clauseXMap, PrismContainerDefinition pcd, boolean preliminaryParsingOnly, PrismContext prismContext) throws SchemaException{
  ItemPath path = getPath(clauseXMap);
  XNode subXFilter = clauseXMap.get(ELEMENT_FILTER);
  ObjectFilter subFilter = null;
  PrismContainerDefinition subPcd = pcd != null ? pcd.findContainerDefinition(path) : null;
  if (subXFilter != null && subXFilter instanceof MapXNode) {
    subFilter = parseFilterInternal((MapXNode) subXFilter, subPcd, preliminaryParsingOnly, prismContext);
  }
  if (preliminaryParsingOnly) {
    return null;
  } else {
    // to report exception only when the filter is really to be used
    checkExtraElements(clauseXMap, ELEMENT_PATH, ELEMENT_FILTER);
    return ExistsFilter.createExists(path, pcd, subFilter);
  }
}

@Test
public void test520ExistsUndefined() throws Exception {
  System.out.println("===[ test520ExistsUndefined ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = QueryBuilder.queryFor(UserType.class, prismContext)
      .exists(UserType.F_ASSIGNMENT).undefined()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", new ItemPath(UserType.F_ASSIGNMENT), existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}

@Override
public String debugDump(int indent) {
  StringBuilder sb = new StringBuilder();
  DebugUtil.indentDebugDump(sb, indent);
  sb.append("EXISTS: ");
  sb.append(fullPath);
  sb.append('\n');
  DebugUtil.indentDebugDump(sb, indent + 1);
  sb.append("DEF: ");
  if (getDefinition() != null) {
    sb.append(getDefinition().toString());
  } else {
    sb.append("null");
  }
  if (filter != null) {
    sb.append(filter.debugDump(indent + 1));
  }
  return sb.toString();
}

@Test
public void test156ExistsAndSomething() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
        .none()
      .and().all()
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      AndFilter.createAnd(
          ExistsFilter.createExists(
              new ItemPath(UserType.F_ASSIGNMENT),
              userPcd,
              NoneFilter.createNone()
          ),
          AllFilter.createAll()
      )
  );
  compare(actual, expected);
}

@Test
public void test150ExistsWithEquals() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
      .item(AssignmentType.F_DESCRIPTION).startsWith("desc1")
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      ExistsFilter.createExists(
          new ItemPath(UserType.F_ASSIGNMENT),
          userPcd,
          SubstringFilter.createSubstring(
              new ItemPath(AssignmentType.F_DESCRIPTION),
              assCtd.findPropertyDefinition(AssignmentType.F_DESCRIPTION),
              getPrismContext(),
              null, "desc1", true, false)
      )
      );
  compare(actual, expected);
}

public static <C extends Containerable> ExistsFilter createExists(ItemPath itemPath, Class<C> clazz, PrismContext prismContext,
                                 ObjectFilter filter) {
  ItemDefinition itemDefinition = FilterUtils.findItemDefinition(itemPath, clazz, prismContext);
  return new ExistsFilter(itemPath, itemDefinition, filter);
}

public ExistsFilter cloneEmpty() {
  return new ExistsFilter(fullPath, definition, null);
}

@Test
public void test500ExistsAll() throws Exception {
  System.out.println("===[ test500ExistsAll ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = QueryBuilder.queryFor(UserType.class, prismContext)
      .exists(UserType.F_ASSIGNMENT).all()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", new ItemPath(UserType.F_ASSIGNMENT), existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}

@Test
public void test151ExistsWithEquals2() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
      .item(AssignmentType.F_NOTE).endsWith("DONE.")
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      ExistsFilter.createExists(
          new ItemPath(UserType.F_ASSIGNMENT),
          userPcd,
          SubstringFilter.createSubstring(
              new ItemPath(AssignmentType.F_NOTE),
              assCtd.findPropertyDefinition(AssignmentType.F_NOTE),
              getPrismContext(),
              null, "DONE.", false, true)
      )
  );
  compare(actual, expected);
}