de.arbeitsagentur.opdt.keycloak.cassandra.role.persistence.RoleDaoImpl__MapperGenerated Maven / Gradle / Ivy

Go to download
package de.arbeitsagentur.opdt.keycloak.cassandra.role.persistence;

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.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.role.persistence.entities.Roles;
import de.arbeitsagentur.opdt.keycloak.cassandra.role.persistence.entities.RolesHelper__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 RoleDaoImpl__MapperGenerated extends DaoBase implements RoleDao {
  private static final Logger LOG = LoggerFactory.getLogger(RoleDaoImpl__MapperGenerated.class);

  private final RolesHelper__MapperGenerated rolesHelper;

  private final PreparedStatement getRolesByRealmIdStatement;

  private final PreparedStatement deleteAllRealmRolesStatement;

  private final PreparedStatement insertStatement;

  private final PreparedStatement updateStatement;

  private final PreparedStatement deleteStatement;

  private RoleDaoImpl__MapperGenerated(MapperContext context,
      RolesHelper__MapperGenerated rolesHelper, PreparedStatement getRolesByRealmIdStatement,
      PreparedStatement deleteAllRealmRolesStatement, PreparedStatement insertStatement,
      PreparedStatement updateStatement, PreparedStatement deleteStatement) {
    super(context);
    this.rolesHelper = rolesHelper;
    this.getRolesByRealmIdStatement = getRolesByRealmIdStatement;
    this.deleteAllRealmRolesStatement = deleteAllRealmRolesStatement;
    this.insertStatement = insertStatement;
    this.updateStatement = updateStatement;
    this.deleteStatement = deleteStatement;
  }

  @Override
  public Roles getRolesByRealmId(String realmId) {
    BoundStatementBuilder boundStatementBuilder = getRolesByRealmIdStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realmId", realmId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    return executeAndMapToSingleEntity(boundStatement, rolesHelper);
  }

  @Override
  public void deleteAllRealmRoles(String realmId) {
    BoundStatementBuilder boundStatementBuilder = deleteAllRealmRolesStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", realmId, String.class);
    BoundStatement boundStatement = boundStatementBuilder.build();
    execute(boundStatement);
  }

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

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

  @Override
  public void delete(Roles entity) {
    BoundStatementBuilder boundStatementBuilder = deleteStatement.boundStatementBuilder();
    boundStatementBuilder = boundStatementBuilder.set("realm_id", entity.getRealmId(), 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
      RolesHelper__MapperGenerated rolesHelper = new RolesHelper__MapperGenerated(context);
      if ((Boolean)context.getCustomState().get("datastax.mapper.schemaValidationEnabled")) {
        rolesHelper.validateEntityFields();
      }
      List> prepareStages = new ArrayList<>();
      // Prepare the statement for `getRolesByRealmId(java.lang.String)`:
      SimpleStatement getRolesByRealmIdStatement_simple = rolesHelper.selectStart().whereRaw("realm_id = :realmId").build();
      LOG.debug("[{}] Preparing query `{}` for method getRolesByRealmId(java.lang.String)",
          context.getSession().getName(),
          getRolesByRealmIdStatement_simple.getQuery());
      CompletionStage getRolesByRealmIdStatement = prepare(getRolesByRealmIdStatement_simple, context);
      prepareStages.add(getRolesByRealmIdStatement);
      // Prepare the statement for `deleteAllRealmRoles(java.lang.String)`:
      SimpleStatement deleteAllRealmRolesStatement_simple = rolesHelper.deleteByPrimaryKeyParts(1).ifExists().build();
      LOG.debug("[{}] Preparing query `{}` for method deleteAllRealmRoles(java.lang.String)",
          context.getSession().getName(),
          deleteAllRealmRolesStatement_simple.getQuery());
      CompletionStage deleteAllRealmRolesStatement = prepare(deleteAllRealmRolesStatement_simple, context);
      prepareStages.add(deleteAllRealmRolesStatement);
      // Prepare the statement for `insert(T)`:
      SimpleStatement insertStatement_simple = rolesHelper.insert().ifNotExists().build();
      LOG.debug("[{}] Preparing query `{}` for method insert(T)",
          context.getSession().getName(),
          insertStatement_simple.getQuery());
      CompletionStage insertStatement = prepare(insertStatement_simple, context);
      prepareStages.add(insertStatement);
      // Prepare the statement for `update(T,long)`:
      SimpleStatement updateStatement_simple = SimpleStatement.newInstance(((DefaultUpdate)rolesHelper.updateByPrimaryKey()).ifRaw("version = :expectedVersion").asCql());
      LOG.debug("[{}] Preparing query `{}` for method update(T,long)",
          context.getSession().getName(),
          updateStatement_simple.getQuery());
      CompletionStage updateStatement = prepare(updateStatement_simple, context);
      prepareStages.add(updateStatement);
      // Prepare the statement for `delete(T)`:
      SimpleStatement deleteStatement_simple = rolesHelper.deleteByPrimaryKeyParts(1).ifExists().build();
      LOG.debug("[{}] Preparing query `{}` for method delete(T)",
          context.getSession().getName(),
          deleteStatement_simple.getQuery());
      CompletionStage deleteStatement = prepare(deleteStatement_simple, context);
      prepareStages.add(deleteStatement);
      // Initialize all method invokers
      // Build the DAO when all statements are prepared
      return CompletableFutures.allSuccessful(prepareStages)
          .thenApply(v -> (RoleDao) new RoleDaoImpl__MapperGenerated(context,
              rolesHelper,
              CompletableFutures.getCompleted(getRolesByRealmIdStatement),
              CompletableFutures.getCompleted(deleteAllRealmRolesStatement),
              CompletableFutures.getCompleted(insertStatement),
              CompletableFutures.getCompleted(updateStatement),
              CompletableFutures.getCompleted(deleteStatement)))
          .toCompletableFuture();
    } catch (Throwable t) {
      return CompletableFutures.failedFuture(t);
    }
  }

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