}

    public RelatedQuery selectEntityWithDeletedCheck(CBCall<RelatedQueryCB> cbLambda) {
        return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
    }

    public OptionalEntity<RelatedQuery> selectByPK(String id) {
        return facadeSelectByPK(id);
    }

    protected OptionalEntity<RelatedQuery> facadeSelectByPK(String id) {
        return doSelectOptionalByPK(id, typeOfSelectedEntity());
    }

    }

    public ScheduledJob selectEntityWithDeletedCheck(CBCall<ScheduledJobCB> cbLambda) {
        return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
    }

    public OptionalEntity<ScheduledJob> selectByPK(String id) {
        return facadeSelectByPK(id);
    }

    protected OptionalEntity<ScheduledJob> facadeSelectByPK(String id) {
        return doSelectOptionalByPK(id, typeOfSelectedEntity());
    }

    }

    public User selectEntityWithDeletedCheck(CBCall<UserCB> cbLambda) {
        return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
    }

    public OptionalEntity<User> selectByPK(String id) {
        return facadeSelectByPK(id);
    }

    protected OptionalEntity<User> facadeSelectByPK(String id) {
        return doSelectOptionalByPK(id, typeOfSelectedEntity());
    }

            return clickLogBhv.selectByPK(id);
        }
        if (SearchLogPager.LOG_TYPE_FAVORITE.equalsIgnoreCase(logType)) {
            return favoriteLogBhv.selectByPK(id);
        }
        if (SearchLogPager.LOG_TYPE_USERINFO.equalsIgnoreCase(logType)) {
            return userInfoBhv.selectByPK(id);
        }
        return searchLogBhv.selectByPK(id);
    }

    /**

     */
    public boolean addUrl(final String userCode, final BiConsumer<UserInfo, FavoriteLog> favoriteLogLambda) {
        return userInfoBhv.selectByPK(userCode).map(userInfo -> {
            final FavoriteLog favoriteLog = new FavoriteLog();
            favoriteLogLambda.accept(userInfo, favoriteLog);
            favoriteLogBhv.insert(favoriteLog);

    /**
     * Gets a role by its ID.
     * @param id The ID of the role.
     * @return An optional entity of the role.
     */
    public OptionalEntity<Role> getRole(final String id) {
        return roleBhv.selectByPK(id);
    }

    /**
     * Stores a role.
     * @param role The role to store.
     */
    public void store(final Role role) {
        ComponentUtil.getLdapManager().insert(role);

     * @return an OptionalEntity containing the RelatedContent if found, empty otherwise
     */
    public OptionalEntity<RelatedContent> getRelatedContent(final String id) {
        return relatedContentBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a related content entity.
     * After storing, updates the related content helper to refresh the cache.
     *

     * @param id the unique identifier of the group
     * @return an OptionalEntity containing the group if found, empty otherwise
     */
    public OptionalEntity<Group> getGroup(final String id) {
        return groupBhv.selectByPK(id).map(g -> {
            ComponentUtil.getLdapManager().apply(g);
            return g;
        });
    }

    /**
     * Stores a group by inserting or updating it in both LDAP and the database.

     * @return an OptionalEntity containing the FailureUrl if found, empty otherwise
     */
    public OptionalEntity<FailureUrl> getFailureUrl(final String id) {
        return failureUrlBhv.selectByPK(id);
    }

    /**
     * Stores or updates a failure URL entity in the data store.
     *
     * @param failureUrl the FailureUrl entity to store or update
     */

     * @param id The ID of the role type.
     * @return An optional entity of the role type.
     */
    public OptionalEntity<RoleType> getRoleType(final String id) {
        return roleTypeBhv.selectByPK(id);
    }

    /**
     * Stores a role type.
     * @param roleType The role type to store.
     */
    public void store(final RoleType roleType) {

        roleTypeBhv.insertOrUpdate(roleType, op -> {