scala.googleapis.bigquery.DatasetsClient.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of googleapis-http4s-bigquery_sjs1_2.13 Show documentation
googleapis-http4s-bigquery
There is a newer version: 0.6.1-v2-20241111
Show newest version
package googleapis.bigquery

import cats.effect.Concurrent
import org.http4s._
import org.http4s.implicits._
import org.http4s.client.Client

class DatasetsClient[F[_]: Concurrent](client: Client[F]) extends AbstractClient[F](client) {
  val baseUri = uri"https://bigquery.googleapis.com/bigquery/v2"
  def undelete(
      /** Required. Project ID of the dataset to be undeleted
        */
      projectId: String,
      /** Required. Dataset ID of dataset being deleted
        */
      datasetId: String,
  )(input: UndeleteDatasetRequest): F[Dataset] = expectJson[Dataset](
    requestWithBody(
      method = Method.POST,
      uri = baseUri / "projects" / s"${projectId}" / "datasets" / s"${datasetId}",
    )(input)
  )
  def insert(
      /** Required. Project ID of the new dataset
        */
      projectId: String
  )(input: Dataset): F[Dataset] = expectJson[Dataset](
    requestWithBody(
      method = Method.POST,
      uri = baseUri / "projects" / s"${projectId}" / "datasets",
    )(input)
  )
  def delete(
      /** Required. Project ID of the dataset being deleted
        */
      projectId: String,
      /** Required. Dataset ID of dataset being deleted
        */
      datasetId: String,
      query: DatasetsClient.DeleteParams = DatasetsClient.DeleteParams(),
  ): F[Status] = client.status(
    request(
      method = Method.DELETE,
      uri = (baseUri / "projects" / s"${projectId}" / "datasets" / s"${datasetId}").copy(query =
        Query.fromVector(
          Vector(
            List(
              "deleteContents" -> query.deleteContents.map(s =>
                QueryParamEncoder[Boolean].encode(s).value
              )
            ).flatMap { case (k, v) => v.map(vv => k -> Option(vv)) }
          ).flatten
        )
      ),
    )
  )
  def get(
      /** Required. Project ID of the requested dataset
        */
      projectId: String,
      /** Required. Dataset ID of the requested dataset
        */
      datasetId: String,
      query: DatasetsClient.GetParams = DatasetsClient.GetParams(),
  ): F[Dataset] = expectJson[Dataset](
    request(
      method = Method.GET,
      uri = (baseUri / "projects" / s"${projectId}" / "datasets" / s"${datasetId}")
        .copy(query = Query.fromVector(Vector(List("datasetView" -> query.datasetView).flatMap {
          case (k, v) => v.map(vv => k -> Option(vv))
        }).flatten)),
    )
  )
  def update(
      /** Required. Project ID of the dataset being updated
        */
      projectId: String,
      /** Required. Dataset ID of the dataset being updated
        */
      datasetId: String,
  )(input: Dataset): F[Dataset] = expectJson[Dataset](
    requestWithBody(
      method = Method.PUT,
      uri = baseUri / "projects" / s"${projectId}" / "datasets" / s"${datasetId}",
    )(input)
  )
  def patch(
      /** Required. Project ID of the dataset being updated
        */
      projectId: String,
      /** Required. Dataset ID of the dataset being updated
        */
      datasetId: String,
  )(input: Dataset): F[Dataset] = expectJson[Dataset](
    requestWithBody(
      method = Method.PATCH,
      uri = baseUri / "projects" / s"${projectId}" / "datasets" / s"${datasetId}",
    )(input)
  )
  def list(
      /** Required. Project ID of the datasets to be listed
        */
      projectId: String,
      query: DatasetsClient.ListParams = DatasetsClient.ListParams(),
  ): F[DatasetList] = expectJson[DatasetList](
    request(
      method = Method.GET,
      uri = (baseUri / "projects" / s"${projectId}" / "datasets").copy(query =
        Query.fromVector(
          Vector(
            List("all" -> query.all.map(s => QueryParamEncoder[Boolean].encode(s).value)).flatMap {
              case (k, v) => v.map(vv => k -> Option(vv))
            },
            List("filter" -> query.filter).flatMap { case (k, v) => v.map(vv => k -> Option(vv)) },
            List("maxResults" -> query.maxResults.map(s => QueryParamEncoder[Int].encode(s).value))
              .flatMap { case (k, v) => v.map(vv => k -> Option(vv)) },
            List("pageToken" -> query.pageToken).flatMap { case (k, v) =>
              v.map(vv => k -> Option(vv))
            },
          ).flatten
        )
      ),
    )
  )
}
object DatasetsClient {
  final case class DeleteParams(
      /** If True, delete all the tables in the dataset. If False and the dataset contains tables, the request will fail. Default is False
        */
      deleteContents: Option[Boolean] = None
  )
  final case class GetParams(
      /** Optional. Specifies the view that determines which dataset information is returned. By default, metadata and ACL information are returned.
        */
      datasetView: Option[String] = None
  )
  final case class ListParams(
      /** Whether to list all datasets, including hidden ones
        */
      all: Option[Boolean] = None,
      /** An expression for filtering the results of the request by label. The syntax is `labels.[:]`. Multiple filters can be ANDed together by connecting with a space. Example: `labels.department:receiving labels.active`. See [Filtering datasets using labels](https://cloud.google.com/bigquery/docs/filtering-labels#filtering_datasets_using_labels) for details.
        */
      filter: Option[String] = None,
      /** The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.
        */
      maxResults: Option[Int] = None,
      /** Page token, returned by a previous call, to request the next page of results
        */
      pageToken: Option[String] = None,
  )
}