private boolean isUseObjectCounting() throws SchemaException {
    MidPointApplication application = (MidPointApplication) getApplication();
    PrismObject<ResourceType> resource = resourceModel.getObject();
    RefinedResourceSchema resourceSchema =
        RefinedResourceSchema.getRefinedSchema(resource, application.getPrismContext());

    // hacking this for now ... in future, we get the type definition (and maybe kind+intent)
    // directly from GUI model
    // TODO here we should deal with the situation that one object class is mentioned in different
    // kind/intent sections -- we would want to avoid mentioning paged search information in all
    // these sections
    ObjectClassComplexTypeDefinition typeDefinition = getAccountDefinition();
    if (typeDefinition == null) {
      // should not occur
      LOGGER.warn("ObjectClass definition couldn't be found");
      return false;
    }

    RefinedObjectClassDefinition refinedObjectClassDefinition =
        resourceSchema.getRefinedDefinition(typeDefinition.getTypeName());
    if (refinedObjectClassDefinition == null) {
      return false;
    }
    return refinedObjectClassDefinition.isObjectCountingEnabled();
  }
  private ResourceAttributeContainer createResourceObject(String dn, String sn, String cn)
      throws SchemaException {
    // Account type is hardcoded now
    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "AccountObjectClass"));
    // Determine identifier from the schema
    ResourceAttributeContainer resourceObject =
        accountDefinition.instantiate(ShadowType.F_ATTRIBUTES);

    ResourceAttributeDefinition road =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "sn"));
    ResourceAttribute roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(sn));
    resourceObject.add(roa);

    road =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "cn"));
    roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(cn));
    resourceObject.add(roa);

    road = accountDefinition.findAttributeDefinition(ConnectorFactoryIcfImpl.ICFS_NAME);
    roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(dn));
    resourceObject.add(roa);

    return resourceObject;
  }
  public static List<String> getIntentsForKind(RefinedResourceSchema rSchema, ShadowKindType kind) {
    List<String> intents = new ArrayList<>();
    for (ObjectClassComplexTypeDefinition objClassDef : rSchema.getObjectClassDefinitions()) {
      if (objClassDef.getKind() == kind) {
        intents.add(objClassDef.getIntent());
      }
    }

    return intents;
  }
  /**
   * Test fetching and translating resource schema.
   *
   * @throws Exception
   */
  @Test
  public void test400FetchResourceSchema() throws Exception {
    final String TEST_NAME = "test400FetchResourceSchema";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN

    // WHEN

    // The schema was fetched during test init. Now just check if it was OK.

    // THEN

    AssertJUnit.assertNotNull(resourceSchema);

    System.out.println(resourceSchema.debugDump());

    Document xsdSchema = resourceSchema.serializeToXsd();

    System.out.println(
        "-------------------------------------------------------------------------------------");
    System.out.println(DOMUtil.printDom(xsdSchema));
    System.out.println(
        "-------------------------------------------------------------------------------------");

    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME));
    AssertJUnit.assertNotNull(accountDefinition);

    AssertJUnit.assertFalse(
        "No identifiers for account object class ", accountDefinition.getIdentifiers().isEmpty());

    PrismPropertyDefinition uidDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME));
    AssertJUnit.assertNotNull(uidDefinition);

    for (Definition def : resourceSchema.getDefinitions()) {
      if (def instanceof ResourceAttributeContainerDefinition) {
        ResourceAttributeContainerDefinition rdef = (ResourceAttributeContainerDefinition) def;
        assertNotEmpty("No type name in object class", rdef.getTypeName());
        assertNotEmpty(
            "No native object class for " + rdef.getTypeName(), rdef.getNativeObjectClass());

        // This is maybe not that important, but just for a sake of
        // completeness
        assertNotEmpty("No name for " + rdef.getTypeName(), rdef.getName());
      }
    }
  }
 private PrismProperty createProperty(String propertyName, String propertyValue) {
   ObjectClassComplexTypeDefinition accountDefinition =
       resourceSchema.findObjectClassDefinition(
           new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "AccountObjectClass"));
   ResourceAttributeDefinition propertyDef =
       accountDefinition.findAttributeDefinition(
           new QName(ResourceTypeUtil.getResourceNamespace(resourceType), propertyName));
   ResourceAttribute property = propertyDef.instantiate();
   property.setValue(new PrismPropertyValue(propertyValue));
   return property;
 }
 private PrismProperty createProperty(String propertyName, String propertyValue) {
   ObjectClassComplexTypeDefinition accountDefinition =
       resourceSchema.findObjectClassDefinition(
           new QName(
               ResourceTypeUtil.getResourceNamespace(resourceType),
               ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME));
   ResourceAttributeDefinition propertyDef =
       accountDefinition.findAttributeDefinition(
           new QName(ResourceTypeUtil.getResourceNamespace(resourceType), propertyName));
   ResourceAttribute property = propertyDef.instantiate();
   property.setValue(new PrismPropertyValue(propertyValue));
   return property;
 }
  /**
   * Test fetching and translating resource schema.
   *
   * @throws Exception
   */
  @Test
  public void testFetchResourceSchema() throws CommunicationException, SchemaException {
    TestUtil.displayTestTile("testFetchResourceSchema");
    // GIVEN

    // WHEN

    // The schema was fetched during test init. Now just check if it was OK.

    // THEN

    AssertJUnit.assertNotNull(resourceSchema);

    System.out.println(resourceSchema.debugDump());

    Document xsdSchema = resourceSchema.serializeToXsd();

    System.out.println(
        "-------------------------------------------------------------------------------------");
    System.out.println(DOMUtil.printDom(xsdSchema));
    System.out.println(
        "-------------------------------------------------------------------------------------");

    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "AccountObjectClass"));
    AssertJUnit.assertNotNull(accountDefinition);

    AssertJUnit.assertFalse(
        "No identifiers for account object class ", accountDefinition.getIdentifiers().isEmpty());

    PrismPropertyDefinition uidDefinition =
        accountDefinition.findPropertyDefinition(ConnectorFactoryIcfImpl.ICFS_UID);
    AssertJUnit.assertNotNull(uidDefinition);

    for (Definition def : resourceSchema.getDefinitions()) {
      if (def instanceof ResourceAttributeContainerDefinition) {
        ResourceAttributeContainerDefinition rdef = (ResourceAttributeContainerDefinition) def;
        assertNotEmpty("No type name in object class", rdef.getTypeName());
        assertNotEmpty(
            "No native object class for " + rdef.getTypeName(), rdef.getNativeObjectClass());

        // This is maybe not that important, but just for a sake of
        // completeness
        assertNotEmpty("No name for " + rdef.getTypeName(), rdef.getName());
      }
    }
  }
 protected void copyDefinitionData(ObjectClassComplexTypeDefinition clone) {
   super.copyDefinitionData(clone);
   clone.kind = this.kind;
   clone.intent = this.intent;
   clone.defaultInAKind = this.defaultInAKind;
   clone.descriptionAttribute = this.descriptionAttribute;
   clone.displayNameAttribute = this.displayNameAttribute;
   clone.identifiers = this.identifiers;
   clone.namingAttribute = this.namingAttribute;
   clone.nativeObjectClass = this.nativeObjectClass;
   clone.secondaryIdentifiers = this.secondaryIdentifiers;
 }
  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;
  }
  private static void parseObjectTypesFromSchema(
      RefinedResourceSchemaImpl rSchema,
      ResourceType resourceType,
      PrismContext prismContext,
      String contextDescription)
      throws SchemaException {

    RefinedObjectClassDefinition rAccountDefDefault = null;
    for (ObjectClassComplexTypeDefinition objectClassDef :
        rSchema.getOriginalResourceSchema().getObjectClassDefinitions()) {
      QName objectClassname = objectClassDef.getTypeName();
      if (rSchema.getRefinedDefinition(objectClassname) != null) {
        continue;
      }
      RefinedObjectClassDefinition rOcDef =
          RefinedObjectClassDefinitionImpl.parseFromSchema(
              objectClassDef,
              resourceType,
              rSchema,
              prismContext,
              "object class " + objectClassname + ", in " + contextDescription);

      if (objectClassDef.getKind() == ShadowKindType.ACCOUNT && rOcDef.isDefault()) {
        if (rAccountDefDefault == null) {
          rAccountDefDefault = rOcDef;
        } else {
          throw new SchemaException(
              "More than one default account definitions ("
                  + rAccountDefDefault
                  + ", "
                  + rOcDef
                  + ") in "
                  + contextDescription);
        }
      }

      rSchema.add(rOcDef);
    }
  }
  private ResourceAttributeContainer createResourceObject(String dn, String sn, String cn)
      throws SchemaException {
    // Account type is hardcoded now
    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME));
    // Determine identifier from the schema
    ResourceAttributeContainer resourceObject =
        accountDefinition.instantiate(ShadowType.F_ATTRIBUTES);

    ResourceAttributeDefinition road =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "sn"));
    ResourceAttribute roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(sn));
    resourceObject.add(roa);

    road =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "cn"));
    roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(cn));
    resourceObject.add(roa);

    road =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME));
    roa = road.instantiate();
    roa.setValue(new PrismPropertyValue(dn));
    resourceObject.add(roa);

    return resourceObject;
  }
  private Collection<ResourceAttribute<?>> addSampleResourceObject(
      String name, String givenName, String familyName)
      throws CommunicationException, GenericFrameworkException, SchemaException,
          ObjectAlreadyExistsException, ConfigurationException {
    OperationResult result = new OperationResult(this.getClass().getName() + ".testAdd");

    QName objectClassQname =
        new QName(
            ResourceTypeUtil.getResourceNamespace(resourceType),
            ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME);
    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(objectClassQname);
    assertNotNull("No object class definition " + objectClassQname, accountDefinition);
    ResourceAttributeContainer resourceObject =
        accountDefinition.instantiate(ShadowType.F_ATTRIBUTES);

    ResourceAttributeDefinition<String> attributeDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME));
    ResourceAttribute<String> attribute = attributeDefinition.instantiate();
    attribute.setValue(
        new PrismPropertyValue<String>("uid=" + name + ",ou=people,dc=example,dc=com"));
    resourceObject.add(attribute);

    attributeDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "sn"));
    attribute = attributeDefinition.instantiate();
    attribute.setValue(new PrismPropertyValue(familyName));
    resourceObject.add(attribute);

    attributeDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "cn"));
    attribute = attributeDefinition.instantiate();
    attribute.setValue(new PrismPropertyValue(givenName + " " + familyName));
    resourceObject.add(attribute);

    attributeDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "givenName"));
    attribute = attributeDefinition.instantiate();
    attribute.setValue(new PrismPropertyValue(givenName));
    resourceObject.add(attribute);

    PrismObject<ShadowType> shadow = wrapInShadow(ShadowType.class, resourceObject);

    Set<Operation> operation = new HashSet<Operation>();
    Collection<ResourceAttribute<?>> resourceAttributes = cc.addObject(shadow, operation, result);
    return resourceAttributes;
  }
  @Test
  public void testResourceSchemaSanity() throws Exception {
    TestUtil.displayTestTile("testResourceSchemaSanity");

    QName objectClassQname =
        new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "AccountObjectClass");
    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(objectClassQname);
    assertNotNull("No object class definition " + objectClassQname, accountDefinition);
    assertEquals(
        "Object class " + objectClassQname + " is not account",
        ShadowKindType.ACCOUNT,
        accountDefinition.getKind());
    assertTrue(
        "Object class " + objectClassQname + " is not default account",
        accountDefinition.isDefaultInAKind());
    assertFalse("Object class " + objectClassQname + " is empty", accountDefinition.isEmpty());
    assertFalse("Object class " + objectClassQname + " is empty", accountDefinition.isIgnored());

    Collection<? extends ResourceAttributeDefinition> identifiers =
        accountDefinition.getIdentifiers();
    assertNotNull("Null identifiers for " + objectClassQname, identifiers);
    assertFalse("Empty identifiers for " + objectClassQname, identifiers.isEmpty());
    // TODO

    ResourceAttributeDefinition attributeDefinition =
        accountDefinition.findAttributeDefinition(ConnectorFactoryIcfImpl.ICFS_UID);
    assertNotNull(
        "No definition for attribute " + ConnectorFactoryIcfImpl.ICFS_UID, attributeDefinition);
    assertTrue(
        "Attribute " + ConnectorFactoryIcfImpl.ICFS_UID + " in not an identifier",
        attributeDefinition.isIdentifier(accountDefinition));
    assertTrue(
        "Attribute " + ConnectorFactoryIcfImpl.ICFS_UID + " in not in identifiers list",
        identifiers.contains(attributeDefinition));
  }
  @Test
  public void test020ResourceSchemaSanity() throws Exception {
    final String TEST_NAME = "test020ResourceSchemaSanity";
    TestUtil.displayTestTile(TEST_NAME);

    QName objectClassQname =
        new QName(
            ResourceTypeUtil.getResourceNamespace(resourceType),
            ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME);
    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(objectClassQname);
    assertNotNull("No object class definition " + objectClassQname, accountDefinition);
    //		assertEquals("Object class " + objectClassQname + " is not account", ShadowKindType.ACCOUNT,
    // accountDefinition.getKind());
    //		assertTrue("Object class " + objectClassQname + " is not default account",
    // accountDefinition.isDefaultInAKind());
    assertFalse("Object class " + objectClassQname + " is empty", accountDefinition.isEmpty());
    assertFalse("Object class " + objectClassQname + " is empty", accountDefinition.isIgnored());

    Collection<? extends ResourceAttributeDefinition> identifiers =
        accountDefinition.getIdentifiers();
    assertNotNull("Null identifiers for " + objectClassQname, identifiers);
    assertFalse("Empty identifiers for " + objectClassQname, identifiers.isEmpty());

    ResourceAttributeDefinition<String> idPrimaryDef =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME));
    assertNotNull(
        "No definition for attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME,
        idPrimaryDef);
    assertTrue(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME
            + " in not an identifier",
        idPrimaryDef.isIdentifier(accountDefinition));
    assertTrue(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME
            + " in not in identifiers list",
        identifiers.contains(idPrimaryDef));
    assertEquals(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME
            + " has wrong native name",
        ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME,
        idPrimaryDef.getNativeAttributeName());
    assertEquals(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME
            + " has wrong framework name",
        Uid.NAME,
        idPrimaryDef.getFrameworkAttributeName());

    ResourceAttributeDefinition<String> idSecondaryDef =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME));
    assertNotNull(
        "No definition for attribute " + ConnectorFactoryIcfImpl.ICFS_NAME, idSecondaryDef);
    assertTrue(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME
            + " in not secondary identifier",
        idSecondaryDef.isSecondaryIdentifier(accountDefinition));
    assertFalse(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME
            + " in in identifiers list and it should NOT be",
        identifiers.contains(idSecondaryDef));
    assertTrue(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME
            + " in not in secomdary identifiers list",
        accountDefinition.getSecondaryIdentifiers().contains(idSecondaryDef));
    assertEquals(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME
            + " has wrong native name",
        ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME,
        idSecondaryDef.getNativeAttributeName());
    assertEquals(
        "Attribute "
            + ProvisioningTestUtil.RESOURCE_OPENDJ_SECONDARY_IDENTIFIER_LOCAL_NAME
            + " has wrong framework name",
        Name.NAME,
        idSecondaryDef.getFrameworkAttributeName());

    assertEquals("Unexpected identifiers: " + identifiers, 1, identifiers.size());
    assertEquals(
        "Unexpected secondary identifiers: " + accountDefinition.getSecondaryIdentifiers(),
        1,
        accountDefinition.getSecondaryIdentifiers().size());
  }
 private QName getObjectClassDefinition() throws SchemaException {
   ObjectClassComplexTypeDefinition def = getAccountDefinition();
   return def != null ? def.getTypeName() : null;
 }