• Home
• de.arbeitsagentur.opdt
• keycloak-cassandra-extension
• 2.2.0-23.0
• source code
• UserDaoImpl__MapperGenerated.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.UserDaoImpl__MapperGenerated Maven / Gradle / Ivy

package de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence;

import com.datastax.oss.driver.api.core.PagingIterable;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import com.datastax.oss.driver.api.mapper.MapperContext;
import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
import com.datastax.oss.driver.internal.core.util.concurrent.BlockingOperation;
import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
import com.datastax.oss.driver.internal.mapper.DaoBase;
import com.datastax.oss.driver.internal.querybuilder.update.DefaultUpdate;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentity;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityHelper__MapperGenerated;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMapping;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMappingHelper__MapperGenerated;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.RealmToUserMapping;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.RealmToUserMappingHelper__MapperGenerated;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.User;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsent;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsentHelper__MapperGenerated;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserHelper__MapperGenerated;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndex;
import de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndexHelper__MapperGenerated;
import java.lang.Boolean;
import java.lang.Override;
import java.lang.String;
import java.lang.SuppressWarnings;
import java.lang.Throwable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Generated by the DataStax driver mapper, do not edit directly.
 */
@SuppressWarnings("all")
public class UserDaoImpl__MapperGenerated extends DaoBase implements UserDao {
  private static final GenericType> GENERIC_TYPE = new GenericType>(){};

  private static final Logger LOG = LoggerFactory.getLogger(UserDaoImpl__MapperGenerated.class);

  private final FederatedIdentityHelper__MapperGenerated federatedIdentityHelper;

  private final FederatedIdentityToUserMappingHelper__MapperGenerated federatedIdentityToUserMappingHelper;

  private final RealmToUserMappingHelper__MapperGenerated realmToUserMappingHelper;

  private final UserHelper__MapperGenerated userHelper;

  private final UserSearchIndexHelper__MapperGenerated userSearchIndexHelper;

  private final UserConsentHelper__MapperGenerated userConsentHelper;

  private final PreparedStatement updateStatement;

  private final PreparedStatement updateStatement1;

  private final PreparedStatement insertStatement;

  private final PreparedStatement countStatement;

  private final PreparedStatement findAllStatement;

  private final PreparedStatement findByIdStatement;

  private final PreparedStatement findByIdsStatement;

  private final PreparedStatement findFederatedIdentityStatement;

  private final PreparedStatement findFederatedIdentityByBrokerUserIdStatement;

  private final PreparedStatement findFederatedIdentitiesStatement;

  private final PreparedStatement findUsersByRealmIdStatement;

  private final PreparedStatement deleteStatement;

  private final PreparedStatement deleteStatement1;

  private final PreparedStatement deleteRealmToUserMappingStatement;

  private final PreparedStatement countAllUsersByRealmIdStatement;

  private final PreparedStatement countNonServiceAccountUsersByRealmIdStatement;

  private final PreparedStatement insertOrUpdateStatement;

  private final PreparedStatement findUsersStatement;

  private final PreparedStatement deleteStatement2;

  private final PreparedStatement deleteIndexStatement;

  private final PreparedStatement insertOrUpdateStatement1;

  private final PreparedStatement deleteStatement3;

  private final PreparedStatement deleteUserConsentStatement;

  private final PreparedStatement deleteUserConsentsByUserIdStatement;

  private final PreparedStatement findUserConsentStatement;

  private final PreparedStatement findUserConsentsByUserIdStatement;

  private final PreparedStatement findUserConsentsByRealmIdStatement;

  private final PreparedStatement insertStatement1;

  private final PreparedStatement updateStatement2;

  private final PreparedStatement deleteStatement4;

  private UserDaoImpl__MapperGenerated(MapperContext context,
      FederatedIdentityHelper__MapperGenerated federatedIdentityHelper,
      FederatedIdentityToUserMappingHelper__MapperGenerated federatedIdentityToUserMappingHelper,
      RealmToUserMappingHelper__MapperGenerated realmToUserMappingHelper,
      UserHelper__MapperGenerated userHelper,
      UserSearchIndexHelper__MapperGenerated userSearchIndexHelper,
      UserConsentHelper__MapperGenerated userConsentHelper, PreparedStatement updateStatement,
      PreparedStatement updateStatement1, PreparedStatement insertStatement,
      PreparedStatement countStatement, PreparedStatement findAllStatement,
      PreparedStatement findByIdStatement, PreparedStatement findByIdsStatement,
      PreparedStatement findFederatedIdentityStatement,
      PreparedStatement findFederatedIdentityByBrokerUserIdStatement,
      PreparedStatement findFederatedIdentitiesStatement,
      PreparedStatement findUsersByRealmIdStatement, PreparedStatement deleteStatement,
      PreparedStatement deleteStatement1, PreparedStatement deleteRealmToUserMappingStatement,
      PreparedStatement countAllUsersByRealmIdStatement,
      PreparedStatement countNonServiceAccountUsersByRealmIdStatement,
      PreparedStatement insertOrUpdateStatement, PreparedStatement findUsersStatement,
      PreparedStatement deleteStatement2, PreparedStatement deleteIndexStatement,
      PreparedStatement insertOrUpdateStatement1, PreparedStatement deleteStatement3,
      PreparedStatement deleteUserConsentStatement,
      PreparedStatement deleteUserConsentsByUserIdStatement,
      PreparedStatement findUserConsentStatement,
      PreparedStatement findUserConsentsByUserIdStatement,
      PreparedStatement findUserConsentsByRealmIdStatement, PreparedStatement insertStatement1,
      PreparedStatement updateStatement2, PreparedStatement deleteStatement4) {
    super(context);
    this.federatedIdentityHelper = federatedIdentityHelper;
    this.federatedIdentityToUserMappingHelper = federatedIdentityToUserMappingHelper;
    this.realmToUserMappingHelper = realmToUserMappingHelper;
    this.userHelper = userHelper;
    this.userSearchIndexHelper = userSearchIndexHelper;
    this.userConsentHelper = userConsentHelper;
    this.updateStatement = updateStatement;
    this.updateStatement1 = updateStatement1;
    this.insertStatement = insertStatement;
    this.countStatement = countStatement;
    this.findAllStatement = findAllStatement;
    this.findByIdStatement = findByIdStatement;
    this.findByIdsStatement = findByIdsStatement;
    this.findFederatedIdentityStatement = findFederatedIdentityStatement;
    this.findFederatedIdentityByBrokerUserIdStatement = findFederatedIdentityByBrokerUserIdStatement;
    this.findFederatedIdentitiesStatement = findFederatedIdentitiesStatement;
    this.findUsersByRealmIdStatement = findUsersByRealmIdStatement;
    this.deleteStatement = deleteStatement;
    this.deleteStatement1 = deleteStatement1;
    this.deleteRealmToUserMappingStatement = deleteRealmToUserMappingStatement;
    this.countAllUsersByRealmIdStatement = countAllUsersByRealmIdStatement;
    this.countNonServiceAccountUsersByRealmIdStatement = countNonServiceAccountUsersByRealmIdStatement;
    this.insertOrUpdateStatement = insertOrUpdateStatement;
    this.findUsersStatement = findUsersStatement;
    this.deleteStatement2 = deleteStatement2;
    this.deleteIndexStatement = deleteIndexStatement;
    this.insertOrUpdateStatement1 = insertOrUpdateStatement1;
    this.deleteStatement3 = deleteStatement3;
    this.deleteUserConsentStatement = deleteUserConsentStatement;
    this.deleteUserConsentsByUserIdStatement = deleteUserConsentsByUserIdStatement;
    this.findUserConsentStatement = findUserConsentStatement;
    this.findUserConsentsByUserIdStatement = findUserConsentsByUserIdStatement;
    this.findUserConsentsByRealmIdStatement = findUserConsentsByRealmIdStatement;
    this.insertStatement1 = insertStatement1;
    this.updateStatement2 = updateStatement2;
    this.deleteStatement4 = deleteStatement4;
  }

  @Override
  public void update(FederatedIdentity federatedIdentity) {
    BoundStatementBuilder boundStatementBuilder = updateStatement.boundStatementBuilder();
    federatedIdentityHelper.set(federatedIdentity, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public void update(FederatedIdentityToUserMapping identityToUserMapping) {
    BoundStatementBuilder boundStatementBuilder = updateStatement1.boundStatementBuilder();
    federatedIdentityToUserMappingHelper.set(identityToUserMapping, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public void insert(RealmToUserMapping realmToUserMapping) {
    BoundStatementBuilder boundStatementBuilder = insertStatement.boundStatementBuilder();
    realmToUserMappingHelper.set(realmToUserMapping, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public long count() {
    BoundStatementBuilder boundStatementBuilder = countStatement.boundStatementBuilder();
    NullSavingStrategy nullSavingStrategy = NullSavingStrategy.SET_TO_NULL;
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapFirstColumnToLong(boundStatement);
  }

  @Override
  public PagingIterable findAll() {
    BoundStatementBuilder boundStatementBuilder = findAllStatement.boundStatementBuilder();
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, userHelper);
  }

  @Override
  public User findById(String realmId, String id) {
    BoundStatementBuilder boundStatementBuilder = findByIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("id", id, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToSingleEntity(boundStatement, userHelper);
  }

  @Override
  public PagingIterable findByIds(String realmId, List ids) {
    BoundStatementBuilder boundStatementBuilder = findByIdsStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("ids", ids, GENERIC_TYPE);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, userHelper);
  }

  @Override
  public FederatedIdentity findFederatedIdentity(String userId, String identityProvider) {
    BoundStatementBuilder boundStatementBuilder = findFederatedIdentityStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("userId", userId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("identityProvider", identityProvider, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToSingleEntity(boundStatement, federatedIdentityHelper);
  }

  @Override
  public FederatedIdentityToUserMapping findFederatedIdentityByBrokerUserId(String brokerUserId,
      String identityProvider) {
    BoundStatementBuilder boundStatementBuilder = findFederatedIdentityByBrokerUserIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("brokerUserId", brokerUserId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("identityProvider", identityProvider, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToSingleEntity(boundStatement, federatedIdentityToUserMappingHelper);
  }

  @Override
  public PagingIterable findFederatedIdentities(String userId) {
    BoundStatementBuilder boundStatementBuilder = findFederatedIdentitiesStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("userId", userId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, federatedIdentityHelper);
  }

  @Override
  public PagingIterable findUsersByRealmId(String realmId) {
    BoundStatementBuilder boundStatementBuilder = findUsersByRealmIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, realmToUserMappingHelper);
  }

  @Override
  public boolean delete(FederatedIdentity federatedIdentity) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("user_id", federatedIdentity.getUserId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("identity_provider", federatedIdentity.getIdentityProvider(), String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapWasAppliedToBoolean(boundStatement);
  }

  @Override
  public boolean delete(FederatedIdentityToUserMapping identityToUserMapping) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement1.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("broker_user_id", identityToUserMapping.getBrokerUserId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("identity_provider", identityToUserMapping.getIdentityProvider(), String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapWasAppliedToBoolean(boundStatement);
  }

  @Override
  public boolean deleteRealmToUserMapping(String realmId, boolean serviceAccount, String userId) {
    BoundStatementBuilder boundStatementBuilder = deleteRealmToUserMappingStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.setBoolean("service_account", serviceAccount);
    boundStatementBuilder = boundStatementBuilder.set("user_id", userId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapWasAppliedToBoolean(boundStatement);
  }

  @Override
  public long countAllUsersByRealmId(String realmId) {
    BoundStatementBuilder boundStatementBuilder = countAllUsersByRealmIdStatement.boundStatementBuilder();
    NullSavingStrategy nullSavingStrategy = NullSavingStrategy.SET_TO_NULL;
    if (realmId != null || nullSavingStrategy == NullSavingStrategy.SET_TO_NULL) {
      boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    }
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapFirstColumnToLong(boundStatement);
  }

  @Override
  public long countNonServiceAccountUsersByRealmId(String realmId) {
    BoundStatementBuilder boundStatementBuilder = countNonServiceAccountUsersByRealmIdStatement.boundStatementBuilder();
    NullSavingStrategy nullSavingStrategy = NullSavingStrategy.SET_TO_NULL;
    if (realmId != null || nullSavingStrategy == NullSavingStrategy.SET_TO_NULL) {
      boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    }
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapFirstColumnToLong(boundStatement);
  }

  @Override
  public void insertOrUpdate(UserSearchIndex searchIndex) {
    BoundStatementBuilder boundStatementBuilder = insertOrUpdateStatement.boundStatementBuilder();
    userSearchIndexHelper.set(searchIndex, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public PagingIterable findUsers(String realmId, String name, String value) {
    BoundStatementBuilder boundStatementBuilder = findUsersStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("name", name, String.class);
    boundStatementBuilder = boundStatementBuilder.set("value", value, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, userSearchIndexHelper);
  }

  @Override
  public void delete(UserSearchIndex searchIndex) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement2.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", searchIndex.getRealmId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("name", searchIndex.getName(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("value", searchIndex.getValue(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("user_id", searchIndex.getUserId(), String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public void deleteIndex(String realmId, String name, String value, String userId) {
    BoundStatementBuilder boundStatementBuilder = deleteIndexStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("name", name, String.class);
    boundStatementBuilder = boundStatementBuilder.set("value", value, String.class);
    boundStatementBuilder = boundStatementBuilder.set("user_id", userId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public void insertOrUpdate(UserConsent userConsent) {
    BoundStatementBuilder boundStatementBuilder = insertOrUpdateStatement1.boundStatementBuilder();
    userConsentHelper.set(userConsent, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public void delete(UserConsent userConsent) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement3.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", userConsent.getRealmId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("user_id", userConsent.getUserId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("client_id", userConsent.getClientId(), String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public boolean deleteUserConsent(String realmId, String userId, String clientId) {
    BoundStatementBuilder boundStatementBuilder = deleteUserConsentStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("user_id", userId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("client_id", clientId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapWasAppliedToBoolean(boundStatement);
  }

  @Override
  public boolean deleteUserConsentsByUserId(String realmId, String userId) {
    BoundStatementBuilder boundStatementBuilder = deleteUserConsentsByUserIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("userId", userId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapWasAppliedToBoolean(boundStatement);
  }

  @Override
  public UserConsent findUserConsent(String realmId, String userId, String clientId) {
    BoundStatementBuilder boundStatementBuilder = findUserConsentStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("userId", userId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("clientId", clientId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToSingleEntity(boundStatement, userConsentHelper);
  }

  @Override
  public PagingIterable findUserConsentsByUserId(String realmId, String userId) {
    BoundStatementBuilder boundStatementBuilder = findUserConsentsByUserIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    boundStatementBuilder = boundStatementBuilder.set("userId", userId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, userConsentHelper);
  }

  @Override
  public PagingIterable findUserConsentsByRealmId(String realmId) {
    BoundStatementBuilder boundStatementBuilder = findUserConsentsByRealmIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToEntityIterable(boundStatement, userConsentHelper);
  }

  @Override
  public void insert(User entity) {
    BoundStatementBuilder boundStatementBuilder = insertStatement1.boundStatementBuilder();
    userHelper.set(entity, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  @Override
  public ResultSet update(User entity, long expectedVersion) {
    BoundStatementBuilder boundStatementBuilder = updateStatement2.boundStatementBuilder();
    userHelper.set(entity, boundStatementBuilder, NullSavingStrategy.SET_TO_NULL, false);
    boundStatementBuilder = boundStatementBuilder.setLong("expectedVersion", expectedVersion);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return execute(boundStatement);
  }

  @Override
  public void delete(User entity) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement4.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", entity.getRealmId(), String.class);
    boundStatementBuilder = boundStatementBuilder.set("id", entity.getId(), String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

  public static CompletableFuture initAsync(MapperContext context) {
    LOG.debug("[{}] Initializing new instance for keyspace = {} and table = {}",
        context.getSession().getName(),
        context.getKeyspaceId(),
        context.getTableId());
    try {
      // Initialize all entity helpers
      FederatedIdentityHelper__MapperGenerated federatedIdentityHelper = new FederatedIdentityHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        federatedIdentityHelper.validateEntityFields();
      }
      FederatedIdentityToUserMappingHelper__MapperGenerated federatedIdentityToUserMappingHelper = new FederatedIdentityToUserMappingHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        federatedIdentityToUserMappingHelper.validateEntityFields();
      }
      RealmToUserMappingHelper__MapperGenerated realmToUserMappingHelper = new RealmToUserMappingHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        realmToUserMappingHelper.validateEntityFields();
      }
      UserHelper__MapperGenerated userHelper = new UserHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        userHelper.validateEntityFields();
      }
      UserSearchIndexHelper__MapperGenerated userSearchIndexHelper = new UserSearchIndexHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        userSearchIndexHelper.validateEntityFields();
      }
      UserConsentHelper__MapperGenerated userConsentHelper = new UserConsentHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        userConsentHelper.validateEntityFields();
      }
      List> prepareStages = new ArrayList<>();
      // Prepare the statement for `update(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentity)`:
      SimpleStatement updateStatement_simple = SimpleStatement.newInstance(((DefaultUpdate)federatedIdentityHelper.updateByPrimaryKey()).asCql());
      LOG.debug("[{}] Preparing query `{}` for method update(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentity)",
          context.getSession().getName(),
          updateStatement_simple.getQuery());
      CompletionStage updateStatement = prepare(updateStatement_simple, context);
      prepareStages.add(updateStatement);
      // Prepare the statement for `update(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMapping)`:
      SimpleStatement updateStatement1_simple = SimpleStatement.newInstance(((DefaultUpdate)federatedIdentityToUserMappingHelper.updateByPrimaryKey()).asCql());
      LOG.debug("[{}] Preparing query `{}` for method update(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMapping)",
          context.getSession().getName(),
          updateStatement1_simple.getQuery());
      CompletionStage updateStatement1 = prepare(updateStatement1_simple, context);
      prepareStages.add(updateStatement1);
      // Prepare the statement for `insert(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.RealmToUserMapping)`:
      SimpleStatement insertStatement_simple = realmToUserMappingHelper.insert().build();
      LOG.debug("[{}] Preparing query `{}` for method insert(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.RealmToUserMapping)",
          context.getSession().getName(),
          insertStatement_simple.getQuery());
      CompletionStage insertStatement = prepare(insertStatement_simple, context);
      prepareStages.add(insertStatement);
      // Prepare the statement for `count()`:
      SimpleStatement countStatement_simple = replaceKeyspaceAndTablePlaceholders("SELECT COUNT(id) FROM users", context, null);
      LOG.debug("[{}] Preparing query `{}` for method count()",
          context.getSession().getName(),
          countStatement_simple.getQuery());
      CompletionStage countStatement = prepare(countStatement_simple, context);
      prepareStages.add(countStatement);
      // Prepare the statement for `findAll()`:
      SimpleStatement findAllStatement_simple = userHelper.selectByPrimaryKeyParts(0).build();
      LOG.debug("[{}] Preparing query `{}` for method findAll()",
          context.getSession().getName(),
          findAllStatement_simple.getQuery());
      CompletionStage findAllStatement = prepare(findAllStatement_simple, context);
      prepareStages.add(findAllStatement);
      // Prepare the statement for `findById(java.lang.String,java.lang.String)`:
      SimpleStatement findByIdStatement_simple = userHelper.selectStart().whereRaw("realm_id = :realmId AND id = :id").build();
      LOG.debug("[{}] Preparing query `{}` for method findById(java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findByIdStatement_simple.getQuery());
      CompletionStage findByIdStatement = prepare(findByIdStatement_simple, context);
      prepareStages.add(findByIdStatement);
      // Prepare the statement for `findByIds(java.lang.String,java.util.List)`:
      SimpleStatement findByIdsStatement_simple = userHelper.selectStart().whereRaw("realm_id = :realmId AND id IN :ids").build();
      LOG.debug("[{}] Preparing query `{}` for method findByIds(java.lang.String,java.util.List)",
          context.getSession().getName(),
          findByIdsStatement_simple.getQuery());
      CompletionStage findByIdsStatement = prepare(findByIdsStatement_simple, context);
      prepareStages.add(findByIdsStatement);
      // Prepare the statement for `findFederatedIdentity(java.lang.String,java.lang.String)`:
      SimpleStatement findFederatedIdentityStatement_simple = federatedIdentityHelper.selectStart().whereRaw("user_id = :userId AND identity_provider = :identityProvider").build();
      LOG.debug("[{}] Preparing query `{}` for method findFederatedIdentity(java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findFederatedIdentityStatement_simple.getQuery());
      CompletionStage findFederatedIdentityStatement = prepare(findFederatedIdentityStatement_simple, context);
      prepareStages.add(findFederatedIdentityStatement);
      // Prepare the statement for `findFederatedIdentityByBrokerUserId(java.lang.String,java.lang.String)`:
      SimpleStatement findFederatedIdentityByBrokerUserIdStatement_simple = federatedIdentityToUserMappingHelper.selectStart().whereRaw("broker_user_id = :brokerUserId AND identity_provider = :identityProvider").build();
      LOG.debug("[{}] Preparing query `{}` for method findFederatedIdentityByBrokerUserId(java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findFederatedIdentityByBrokerUserIdStatement_simple.getQuery());
      CompletionStage findFederatedIdentityByBrokerUserIdStatement = prepare(findFederatedIdentityByBrokerUserIdStatement_simple, context);
      prepareStages.add(findFederatedIdentityByBrokerUserIdStatement);
      // Prepare the statement for `findFederatedIdentities(java.lang.String)`:
      SimpleStatement findFederatedIdentitiesStatement_simple = federatedIdentityHelper.selectStart().whereRaw("user_id = :userId").build();
      LOG.debug("[{}] Preparing query `{}` for method findFederatedIdentities(java.lang.String)",
          context.getSession().getName(),
          findFederatedIdentitiesStatement_simple.getQuery());
      CompletionStage findFederatedIdentitiesStatement = prepare(findFederatedIdentitiesStatement_simple, context);
      prepareStages.add(findFederatedIdentitiesStatement);
      // Prepare the statement for `findUsersByRealmId(java.lang.String)`:
      SimpleStatement findUsersByRealmIdStatement_simple = realmToUserMappingHelper.selectStart().whereRaw("realm_id = :realmId").build();
      LOG.debug("[{}] Preparing query `{}` for method findUsersByRealmId(java.lang.String)",
          context.getSession().getName(),
          findUsersByRealmIdStatement_simple.getQuery());
      CompletionStage findUsersByRealmIdStatement = prepare(findUsersByRealmIdStatement_simple, context);
      prepareStages.add(findUsersByRealmIdStatement);
      // Prepare the statement for `delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentity)`:
      SimpleStatement deleteStatement_simple = federatedIdentityHelper.deleteByPrimaryKeyParts(2).build();
      LOG.debug("[{}] Preparing query `{}` for method delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentity)",
          context.getSession().getName(),
          deleteStatement_simple.getQuery());
      CompletionStage deleteStatement = prepare(deleteStatement_simple, context);
      prepareStages.add(deleteStatement);
      // Prepare the statement for `delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMapping)`:
      SimpleStatement deleteStatement1_simple = federatedIdentityToUserMappingHelper.deleteByPrimaryKeyParts(2).build();
      LOG.debug("[{}] Preparing query `{}` for method delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.FederatedIdentityToUserMapping)",
          context.getSession().getName(),
          deleteStatement1_simple.getQuery());
      CompletionStage deleteStatement1 = prepare(deleteStatement1_simple, context);
      prepareStages.add(deleteStatement1);
      // Prepare the statement for `deleteRealmToUserMapping(java.lang.String,boolean,java.lang.String)`:
      SimpleStatement deleteRealmToUserMappingStatement_simple = realmToUserMappingHelper.deleteByPrimaryKeyParts(3).build();
      LOG.debug("[{}] Preparing query `{}` for method deleteRealmToUserMapping(java.lang.String,boolean,java.lang.String)",
          context.getSession().getName(),
          deleteRealmToUserMappingStatement_simple.getQuery());
      CompletionStage deleteRealmToUserMappingStatement = prepare(deleteRealmToUserMappingStatement_simple, context);
      prepareStages.add(deleteRealmToUserMappingStatement);
      // Prepare the statement for `countAllUsersByRealmId(java.lang.String)`:
      SimpleStatement countAllUsersByRealmIdStatement_simple = replaceKeyspaceAndTablePlaceholders("SELECT count(user_id) FROM realms_to_users WHERE realm_id = :realmId", context, null);
      LOG.debug("[{}] Preparing query `{}` for method countAllUsersByRealmId(java.lang.String)",
          context.getSession().getName(),
          countAllUsersByRealmIdStatement_simple.getQuery());
      CompletionStage countAllUsersByRealmIdStatement = prepare(countAllUsersByRealmIdStatement_simple, context);
      prepareStages.add(countAllUsersByRealmIdStatement);
      // Prepare the statement for `countNonServiceAccountUsersByRealmId(java.lang.String)`:
      SimpleStatement countNonServiceAccountUsersByRealmIdStatement_simple = replaceKeyspaceAndTablePlaceholders("SELECT count(user_id) FROM realms_to_users WHERE realm_id = :realmId AND service_account = false", context, null);
      LOG.debug("[{}] Preparing query `{}` for method countNonServiceAccountUsersByRealmId(java.lang.String)",
          context.getSession().getName(),
          countNonServiceAccountUsersByRealmIdStatement_simple.getQuery());
      CompletionStage countNonServiceAccountUsersByRealmIdStatement = prepare(countNonServiceAccountUsersByRealmIdStatement_simple, context);
      prepareStages.add(countNonServiceAccountUsersByRealmIdStatement);
      // Prepare the statement for `insertOrUpdate(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndex)`:
      SimpleStatement insertOrUpdateStatement_simple = userSearchIndexHelper.insert().build();
      LOG.debug("[{}] Preparing query `{}` for method insertOrUpdate(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndex)",
          context.getSession().getName(),
          insertOrUpdateStatement_simple.getQuery());
      CompletionStage insertOrUpdateStatement = prepare(insertOrUpdateStatement_simple, context);
      prepareStages.add(insertOrUpdateStatement);
      // Prepare the statement for `findUsers(java.lang.String,java.lang.String,java.lang.String)`:
      SimpleStatement findUsersStatement_simple = userSearchIndexHelper.selectStart().whereRaw("realm_id = :realmId AND name = :name AND value = :value").build();
      LOG.debug("[{}] Preparing query `{}` for method findUsers(java.lang.String,java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findUsersStatement_simple.getQuery());
      CompletionStage findUsersStatement = prepare(findUsersStatement_simple, context);
      prepareStages.add(findUsersStatement);
      // Prepare the statement for `delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndex)`:
      SimpleStatement deleteStatement2_simple = userSearchIndexHelper.deleteByPrimaryKeyParts(4).build();
      LOG.debug("[{}] Preparing query `{}` for method delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserSearchIndex)",
          context.getSession().getName(),
          deleteStatement2_simple.getQuery());
      CompletionStage deleteStatement2 = prepare(deleteStatement2_simple, context);
      prepareStages.add(deleteStatement2);
      // Prepare the statement for `deleteIndex(java.lang.String,java.lang.String,java.lang.String,java.lang.String)`:
      SimpleStatement deleteIndexStatement_simple = userSearchIndexHelper.deleteByPrimaryKeyParts(4).build();
      LOG.debug("[{}] Preparing query `{}` for method deleteIndex(java.lang.String,java.lang.String,java.lang.String,java.lang.String)",
          context.getSession().getName(),
          deleteIndexStatement_simple.getQuery());
      CompletionStage deleteIndexStatement = prepare(deleteIndexStatement_simple, context);
      prepareStages.add(deleteIndexStatement);
      // Prepare the statement for `insertOrUpdate(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsent)`:
      SimpleStatement insertOrUpdateStatement1_simple = userConsentHelper.insert().build();
      LOG.debug("[{}] Preparing query `{}` for method insertOrUpdate(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsent)",
          context.getSession().getName(),
          insertOrUpdateStatement1_simple.getQuery());
      CompletionStage insertOrUpdateStatement1 = prepare(insertOrUpdateStatement1_simple, context);
      prepareStages.add(insertOrUpdateStatement1);
      // Prepare the statement for `delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsent)`:
      SimpleStatement deleteStatement3_simple = userConsentHelper.deleteByPrimaryKeyParts(3).build();
      LOG.debug("[{}] Preparing query `{}` for method delete(de.arbeitsagentur.opdt.keycloak.cassandra.user.persistence.entities.UserConsent)",
          context.getSession().getName(),
          deleteStatement3_simple.getQuery());
      CompletionStage deleteStatement3 = prepare(deleteStatement3_simple, context);
      prepareStages.add(deleteStatement3);
      // Prepare the statement for `deleteUserConsent(java.lang.String,java.lang.String,java.lang.String)`:
      SimpleStatement deleteUserConsentStatement_simple = userConsentHelper.deleteByPrimaryKeyParts(3).build();
      LOG.debug("[{}] Preparing query `{}` for method deleteUserConsent(java.lang.String,java.lang.String,java.lang.String)",
          context.getSession().getName(),
          deleteUserConsentStatement_simple.getQuery());
      CompletionStage deleteUserConsentStatement = prepare(deleteUserConsentStatement_simple, context);
      prepareStages.add(deleteUserConsentStatement);
      // Prepare the statement for `deleteUserConsentsByUserId(java.lang.String,java.lang.String)`:
      SimpleStatement deleteUserConsentsByUserIdStatement_simple = userConsentHelper.deleteStart().whereRaw("realm_id = :realmId AND user_id = :userId").build();
      LOG.debug("[{}] Preparing query `{}` for method deleteUserConsentsByUserId(java.lang.String,java.lang.String)",
          context.getSession().getName(),
          deleteUserConsentsByUserIdStatement_simple.getQuery());
      CompletionStage deleteUserConsentsByUserIdStatement = prepare(deleteUserConsentsByUserIdStatement_simple, context);
      prepareStages.add(deleteUserConsentsByUserIdStatement);
      // Prepare the statement for `findUserConsent(java.lang.String,java.lang.String,java.lang.String)`:
      SimpleStatement findUserConsentStatement_simple = userConsentHelper.selectStart().whereRaw("realm_id = :realmId AND user_id = :userId AND client_id = :clientId").build();
      LOG.debug("[{}] Preparing query `{}` for method findUserConsent(java.lang.String,java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findUserConsentStatement_simple.getQuery());
      CompletionStage findUserConsentStatement = prepare(findUserConsentStatement_simple, context);
      prepareStages.add(findUserConsentStatement);
      // Prepare the statement for `findUserConsentsByUserId(java.lang.String,java.lang.String)`:
      SimpleStatement findUserConsentsByUserIdStatement_simple = userConsentHelper.selectStart().whereRaw("realm_id = :realmId AND user_id = :userId").build();
      LOG.debug("[{}] Preparing query `{}` for method findUserConsentsByUserId(java.lang.String,java.lang.String)",
          context.getSession().getName(),
          findUserConsentsByUserIdStatement_simple.getQuery());
      CompletionStage findUserConsentsByUserIdStatement = prepare(findUserConsentsByUserIdStatement_simple, context);
      prepareStages.add(findUserConsentsByUserIdStatement);
      // Prepare the statement for `findUserConsentsByRealmId(java.lang.String)`:
      SimpleStatement findUserConsentsByRealmIdStatement_simple = userConsentHelper.selectStart().whereRaw("realm_id = :realmId").build();
      LOG.debug("[{}] Preparing query `{}` for method findUserConsentsByRealmId(java.lang.String)",
          context.getSession().getName(),
          findUserConsentsByRealmIdStatement_simple.getQuery());
      CompletionStage findUserConsentsByRealmIdStatement = prepare(findUserConsentsByRealmIdStatement_simple, context);
      prepareStages.add(findUserConsentsByRealmIdStatement);
      // Prepare the statement for `insert(T)`:
      SimpleStatement insertStatement1_simple = userHelper.insert().ifNotExists().build();
      LOG.debug("[{}] Preparing query `{}` for method insert(T)",
          context.getSession().getName(),
          insertStatement1_simple.getQuery());
      CompletionStage insertStatement1 = prepare(insertStatement1_simple, context);
      prepareStages.add(insertStatement1);
      // Prepare the statement for `update(T,long)`:
      SimpleStatement updateStatement2_simple = SimpleStatement.newInstance(((DefaultUpdate)userHelper.updateByPrimaryKey()).ifRaw("version = :expectedVersion").asCql());
      LOG.debug("[{}] Preparing query `{}` for method update(T,long)",
          context.getSession().getName(),
          updateStatement2_simple.getQuery());
      CompletionStage updateStatement2 = prepare(updateStatement2_simple, context);
      prepareStages.add(updateStatement2);
      // Prepare the statement for `delete(T)`:
      SimpleStatement deleteStatement4_simple = userHelper.deleteByPrimaryKeyParts(2).ifExists().build();
      LOG.debug("[{}] Preparing query `{}` for method delete(T)",
          context.getSession().getName(),
          deleteStatement4_simple.getQuery());
      CompletionStage deleteStatement4 = prepare(deleteStatement4_simple, context);
      prepareStages.add(deleteStatement4);
      // Initialize all method invokers
      // Build the DAO when all statements are prepared
      return CompletableFutures.allSuccessful(prepareStages)
          .thenApply(v -> (UserDao) new UserDaoImpl__MapperGenerated(context,
              federatedIdentityHelper,
              federatedIdentityToUserMappingHelper,
              realmToUserMappingHelper,
              userHelper,
              userSearchIndexHelper,
              userConsentHelper,
              CompletableFutures.getCompleted(updateStatement),
              CompletableFutures.getCompleted(updateStatement1),
              CompletableFutures.getCompleted(insertStatement),
              CompletableFutures.getCompleted(countStatement),
              CompletableFutures.getCompleted(findAllStatement),
              CompletableFutures.getCompleted(findByIdStatement),
              CompletableFutures.getCompleted(findByIdsStatement),
              CompletableFutures.getCompleted(findFederatedIdentityStatement),
              CompletableFutures.getCompleted(findFederatedIdentityByBrokerUserIdStatement),
              CompletableFutures.getCompleted(findFederatedIdentitiesStatement),
              CompletableFutures.getCompleted(findUsersByRealmIdStatement),
              CompletableFutures.getCompleted(deleteStatement),
              CompletableFutures.getCompleted(deleteStatement1),
              CompletableFutures.getCompleted(deleteRealmToUserMappingStatement),
              CompletableFutures.getCompleted(countAllUsersByRealmIdStatement),
              CompletableFutures.getCompleted(countNonServiceAccountUsersByRealmIdStatement),
              CompletableFutures.getCompleted(insertOrUpdateStatement),
              CompletableFutures.getCompleted(findUsersStatement),
              CompletableFutures.getCompleted(deleteStatement2),
              CompletableFutures.getCompleted(deleteIndexStatement),
              CompletableFutures.getCompleted(insertOrUpdateStatement1),
              CompletableFutures.getCompleted(deleteStatement3),
              CompletableFutures.getCompleted(deleteUserConsentStatement),
              CompletableFutures.getCompleted(deleteUserConsentsByUserIdStatement),
              CompletableFutures.getCompleted(findUserConsentStatement),
              CompletableFutures.getCompleted(findUserConsentsByUserIdStatement),
              CompletableFutures.getCompleted(findUserConsentsByRealmIdStatement),
              CompletableFutures.getCompleted(insertStatement1),
              CompletableFutures.getCompleted(updateStatement2),
              CompletableFutures.getCompleted(deleteStatement4)))
          .toCompletableFuture();
    } catch (Throwable t) {
      return CompletableFutures.failedFuture(t);
    }
  }

  public static UserDao init(MapperContext context) {
    BlockingOperation.checkNotDriverThread();
    return CompletableFutures.getUninterruptibly(initAsync(context));
  }
}