private ObjectQuery getAssociationsSearchQuery(
PrismContext prismContext,
PrismObject resource,
QName objectClass,
ShadowKindType kind,
String intent) {
try {
ObjectFilter andFilter =
AndFilter.createAnd(
EqualFilter.createEqual(
ShadowType.F_OBJECT_CLASS, ShadowType.class, prismContext, objectClass),
EqualFilter.createEqual(ShadowType.F_KIND, ShadowType.class, prismContext, kind),
// EqualFilter.createEqual(ShadowType.F_INTENT, ShadowType.class,
// prismContext, intent),
RefFilter.createReferenceEqual(
new ItemPath(ShadowType.F_RESOURCE_REF),
ShadowType.class,
prismContext,
resource.getOid()));
ObjectQuery query = ObjectQuery.createObjectQuery(andFilter);
return query;
} catch (SchemaException ex) {
LoggingUtils.logUnexpectedException(LOGGER, "Unable to create associations search query", ex);
return null;
}
}
private ObjectQuery createQuery() {
AccountContentSearchDto dto = searchModel.getObject();
if (StringUtils.isEmpty(dto.getSearchText())) {
return null;
}
try {
ObjectQuery query = null;
List<ObjectFilter> conditions = new ArrayList<>();
ObjectClassComplexTypeDefinition def = getAccountDefinition();
if (dto.isIdentifiers()) {
List<ResourceAttributeDefinition> identifiers = new ArrayList<>();
if (def.getIdentifiers() != null) {
identifiers.addAll(def.getIdentifiers());
}
// TODO set matching rule instead fo null
for (ResourceAttributeDefinition attrDef : identifiers) {
conditions.add(
EqualFilter.createEqual(
new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()),
attrDef,
dto.getSearchText()));
}
}
if (dto.isName()) {
List<ResourceAttributeDefinition> secondaryIdentifiers = new ArrayList<>();
if (def.getNamingAttribute() != null) {
secondaryIdentifiers.add(def.getNamingAttribute());
} else if (def.getSecondaryIdentifiers() != null) {
secondaryIdentifiers.addAll(def.getSecondaryIdentifiers());
}
for (ResourceAttributeDefinition attrDef : secondaryIdentifiers) {
conditions.add(
SubstringFilter.createSubstring(
new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()),
attrDef,
dto.getSearchText()));
}
}
if (!conditions.isEmpty()) {
if (conditions.size() > 1) {
query = ObjectQuery.createObjectQuery(OrFilter.createOr(conditions));
} else {
query = ObjectQuery.createObjectQuery(conditions.get(0));
}
}
return query;
} catch (Exception ex) {
error(getString("pageUsers.message.queryError") + " " + ex.getMessage());
LoggingUtils.logException(LOGGER, "Couldn't create query filter.", ex);
}
return null;
}
public static <T extends ObjectType> ObjectQuery createNameQuery(
Class<T> clazz, PrismContext prismContext, String name) throws SchemaException {
PolyString namePolyString = new PolyString(name);
EqualFilter equal =
EqualFilter.createEqual(ObjectType.F_NAME, clazz, prismContext, null, namePolyString);
return ObjectQuery.createObjectQuery(equal);
}
public static ObjectQuery createOrigNameQuery(PolyString name, PrismContext prismContext)
throws SchemaException {
EqualFilter filter =
EqualFilter.createEqual(
ObjectType.F_NAME,
ObjectType.class,
prismContext,
PolyStringOrigMatchingRule.NAME,
name);
return ObjectQuery.createObjectQuery(filter);
}
private void repositorySelfTestUser(Task task, OperationResult testResult) {
OperationResult result = testResult.createSubresult(REPOSITORY_SELF_TEST_USER);
PrismObject<UserType> user = getObjectDefinition(UserType.class).instantiate();
UserType userType = user.asObjectable();
String name = generateRandomName();
PolyStringType namePolyStringType = toPolyStringType(name);
userType.setName(namePolyStringType);
result.addContext("name", name);
userType.setDescription(SelfTestData.POLICIJA);
userType.setFullName(toPolyStringType(USER_FULL_NAME));
userType.setGivenName(toPolyStringType(USER_GIVEN_NAME));
userType.setFamilyName(toPolyStringType(USER_FAMILY_NAME));
userType.setTitle(toPolyStringType(INSANE_NATIONAL_STRING));
userType.getEmployeeType().add(USER_EMPLOYEE_TYPE[0]);
userType.getEmployeeType().add(USER_EMPLOYEE_TYPE[1]);
userType.getOrganization().add(toPolyStringType(USER_ORGANIZATION[0]));
userType.getOrganization().add(toPolyStringType(USER_ORGANIZATION[1]));
String oid;
try {
oid = repositoryService.addObject(user, null, result);
} catch (ObjectAlreadyExistsException e) {
result.recordFatalError(e);
return;
} catch (SchemaException e) {
result.recordFatalError(e);
return;
} catch (RuntimeException e) {
result.recordFatalError(e);
return;
}
try {
{
OperationResult subresult = result.createSubresult(result.getOperation() + ".getObject");
PrismObject<UserType> userRetrieved;
try {
userRetrieved = repositoryService.getObject(UserType.class, oid, null, subresult);
} catch (ObjectNotFoundException e) {
result.recordFatalError(e);
return;
} catch (SchemaException e) {
result.recordFatalError(e);
return;
} catch (RuntimeException e) {
result.recordFatalError(e);
return;
}
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Self-test:user getObject:\n{}", userRetrieved.debugDump());
}
checkUser(userRetrieved, name, subresult);
subresult.recordSuccessIfUnknown();
}
{
OperationResult subresult =
result.createSubresult(result.getOperation() + ".searchObjects.fullName");
try {
ObjectQuery query = new ObjectQuery();
ObjectFilter filter =
EqualFilter.createEqual(
UserType.F_FULL_NAME,
UserType.class,
prismContext,
null,
toPolyString(USER_FULL_NAME));
query.setFilter(filter);
subresult.addParam("query", query);
List<PrismObject<UserType>> foundObjects =
repositoryService.searchObjects(UserType.class, query, null, subresult);
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
}
assertSingleSearchResult("user", foundObjects, subresult);
PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
checkUser(userRetrieved, name, subresult);
subresult.recordSuccessIfUnknown();
} catch (SchemaException e) {
subresult.recordFatalError(e);
return;
} catch (RuntimeException e) {
subresult.recordFatalError(e);
return;
}
}
// MID-1116
{
OperationResult subresult =
result.createSubresult(result.getOperation() + ".searchObjects.employeeType");
try {
ObjectQuery query = new ObjectQuery();
ObjectFilter filter =
EqualFilter.createEqual(
UserType.F_EMPLOYEE_TYPE,
UserType.class,
prismContext,
null,
USER_EMPLOYEE_TYPE[0]);
query.setFilter(filter);
subresult.addParam("query", query);
List<PrismObject<UserType>> foundObjects =
repositoryService.searchObjects(UserType.class, query, null, subresult);
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
}
assertSingleSearchResult("user", foundObjects, subresult);
PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
checkUser(userRetrieved, name, subresult);
subresult.recordSuccessIfUnknown();
} catch (SchemaException e) {
subresult.recordFatalError(e);
return;
} catch (RuntimeException e) {
subresult.recordFatalError(e);
return;
}
}
// MID-1116
{
OperationResult subresult =
result.createSubresult(result.getOperation() + ".searchObjects.organization");
try {
ObjectQuery query = new ObjectQuery();
ObjectFilter filter =
EqualFilter.createEqual(
UserType.F_ORGANIZATION,
UserType.class,
prismContext,
null,
toPolyString(USER_ORGANIZATION[1]));
query.setFilter(filter);
subresult.addParam("query", query);
List<PrismObject<UserType>> foundObjects =
repositoryService.searchObjects(UserType.class, query, null, subresult);
if (LOGGER.isTraceEnabled()) {
LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
}
assertSingleSearchResult("user", foundObjects, subresult);
PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
checkUser(userRetrieved, name, subresult);
subresult.recordSuccessIfUnknown();
} catch (SchemaException e) {
subresult.recordFatalError(e);
return;
} catch (RuntimeException e) {
subresult.recordFatalError(e);
return;
}
}
} finally {
try {
repositoryService.deleteObject(UserType.class, oid, testResult);
} catch (ObjectNotFoundException e) {
result.recordFatalError(e);
return;
} catch (RuntimeException e) {
result.recordFatalError(e);
return;
}
result.computeStatus();
}
}
<C extends Containerable, T> EqualFilter<T> createEqualFilter(
ItemPath propertyPath, Class<C> type, T realValues) throws SchemaException {
return EqualFilter.createEqual(propertyPath, type, prismContext, realValues);
}
public static ObjectFilter createObjectClassFilter(QName objectClass, PrismContext prismContext) {
return EqualFilter.createEqual(
ShadowType.F_OBJECT_CLASS, ShadowType.class, prismContext, null, objectClass);
}