/** * Generated by API Builder - https://www.apibuilder.io * Service version: 0.12.53 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-internal/0.12.53/http4s_0_20 */ package io.apibuilder.internal.v0.models { sealed trait TaskData extends _root_.scala.Product with _root_.scala.Serializable /** * @param numberAttempts Records the number of times we have attempted to run this task. Commonly we * increment number attempts, process the task, and if succeeds we then delete the * task. If it fails, we update last_error. This allows us to retry a task say * twice; after which we no longer process the task (can notify an admin of the * error). */ final case class Task( guid: _root_.java.util.UUID, data: io.apibuilder.internal.v0.models.TaskData, numberAttempts: Long = 0L, lastError: _root_.scala.Option[String] = None ) final case class TaskDataDiffVersion( oldVersionGuid: _root_.java.util.UUID, newVersionGuid: _root_.java.util.UUID ) extends TaskData final case class TaskDataIndexApplication( applicationGuid: _root_.java.util.UUID ) extends TaskData /** * Provides future compatibility in clients - in the future, when a type is added * to the union TaskData, it will need to be handled in the client code. This * implementation will deserialize these future types as an instance of this class. * * @param description Information about the type that we received that is undefined in this version of * the client. */ final case class TaskDataUndefinedType( description: String ) extends TaskData } package io.apibuilder.internal.v0.models { package object json { import io.circe.Decoder._ import io.circe.Encoder._ import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic import scala.util.Try import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure} import io.circe.syntax._ import io.apibuilder.internal.v0.models.json._ // Make Scala 2.11 Either monadic private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e) private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] = Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str))) private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] = Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString) private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] = Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant)) private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] = Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString) private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] = Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str))) private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] = Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString) implicit def decodeApibuilderInternalTask: Decoder[Task] = Decoder.instance { c => for { guid <- c.downField("guid").as[_root_.java.util.UUID] data <- c.downField("data").as[io.apibuilder.internal.v0.models.TaskData] numberAttempts <- c.downField("number_attempts").as[Long] lastError <- c.downField("last_error").as[Option[String]] } yield { Task( guid = guid, data = data, numberAttempts = numberAttempts, lastError = lastError ) } } implicit def encodeApibuilderInternalTask: Encoder[Task] = Encoder.instance { t => Json.fromFields(Seq( Some("guid" -> t.guid.asJson), Some("data" -> t.data.asJson), Some("number_attempts" -> t.numberAttempts.asJson), t.lastError.map(t => "last_error" -> t.asJson) ).flatten) } implicit def decodeApibuilderInternalTaskDataDiffVersion: Decoder[TaskDataDiffVersion] = Decoder.instance { c => for { oldVersionGuid <- c.downField("old_version_guid").as[_root_.java.util.UUID] newVersionGuid <- c.downField("new_version_guid").as[_root_.java.util.UUID] } yield { TaskDataDiffVersion( oldVersionGuid = oldVersionGuid, newVersionGuid = newVersionGuid ) } } implicit def encodeApibuilderInternalTaskDataDiffVersion: Encoder[TaskDataDiffVersion] = Encoder.instance { t => Json.fromFields(Seq( Some("old_version_guid" -> t.oldVersionGuid.asJson), Some("new_version_guid" -> t.newVersionGuid.asJson) ).flatten) } implicit def decodeApibuilderInternalTaskDataIndexApplication: Decoder[TaskDataIndexApplication] = Decoder.instance { c => for { applicationGuid <- c.downField("application_guid").as[_root_.java.util.UUID] } yield { TaskDataIndexApplication( applicationGuid = applicationGuid ) } } implicit def encodeApibuilderInternalTaskDataIndexApplication: Encoder[TaskDataIndexApplication] = Encoder.instance { t => Json.fromFields(Seq( Some("application_guid" -> t.applicationGuid.asJson) ).flatten) } implicit def decodeApibuilderInternalTaskData: Decoder[TaskData] = Decoder.instance { c => c.get[io.apibuilder.internal.v0.models.TaskDataIndexApplication]("task_data_index_application") orElse c.get[io.apibuilder.internal.v0.models.TaskDataDiffVersion]("task_data_diff_version") orElse Right(io.apibuilder.internal.v0.models.TaskDataUndefinedType(c.value.toString)) } implicit def encodeApibuilderInternalTaskData: Encoder[TaskData] = Encoder.instance { case t: io.apibuilder.internal.v0.models.TaskDataIndexApplication => Json.fromJsonObject(JsonObject.singleton("task_data_index_application", t.asJson)) case t: io.apibuilder.internal.v0.models.TaskDataDiffVersion => Json.fromJsonObject(JsonObject.singleton("task_data_diff_version", t.asJson)) case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder") } } } package io.apibuilder.internal.v0 { import cats.effect._ import cats.implicits._ import io.circe.syntax._ object Constants { val Namespace = "io.apibuilder.internal.v0" val UserAgent = "apibuilder app.apibuilder.io/apicollective/apibuilder-internal/0.12.53/http4s_0_20" val Version = "0.12.53" val VersionMajor = 0 } class Client[F[_]: Sync]( val baseUrl: org.http4s.Uri, auth: scala.Option[io.apibuilder.internal.v0.Authorization] = None, defaultHeaders: Seq[(String, String)] = Nil, httpClient: org.http4s.client.Client[F] ) extends interfaces.Client[F] { import org.http4s.Response import io.apibuilder.internal.v0.models.json._ private lazy val defaultApiHeaders = Seq( ("User-Agent", Constants.UserAgent), ("X-Apidoc-Version", Constants.Version), ("X-Apidoc-Version-Major", Constants.VersionMajor.toString) ) def apiHeaders: Seq[(String, String)] = defaultApiHeaders def modifyRequest(request: org.http4s.Request[F]): org.http4s.Request[F] = request implicit def circeJsonEncoder[F[_]: Sync, A](implicit encoder: io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[F, A] def _executeRequest[T, U]( method: String, path: Seq[String], queryParameters: Seq[(String, String)] = Nil, requestHeaders: Seq[(String, String)] = Nil, body: Option[T] = None, formBody : Option[org.http4s.UrlForm] = None )(handler: org.http4s.Response[F] => F[U] )(implicit encoder: io.circe.Encoder[T]): F[U] = { import org.http4s.QueryParamEncoder._ val m = org.http4s.Method.fromString(method) match { case Right(m) => m case Left(e) => sys.error(e.toString) } val headers = org.http4s.Headers(( apiHeaders ++ defaultHeaders ++ requestHeaders ).groupBy(_._1).map { case (k, l) => org.http4s.Header(k, l.last._2) }.toList) val queryMap = queryParameters.groupBy(_._1).map { case (k, v) => k -> v.map(_._2) } val uri = path.foldLeft(baseUrl){ case (uri, segment) => uri / segment }.setQueryParams(queryMap) val request = org.http4s.Request[F](method = m, uri = uri, headers = headers) val reqAndMaybeAuth = auth.fold(request) { case Authorization.Basic(username, passwordOpt) => { val userpass = s"$username:${passwordOpt.getOrElse("")}" val token = java.util.Base64.getEncoder.encodeToString(userpass.getBytes(java.nio.charset.StandardCharsets.ISO_8859_1)) request.putHeaders(org.http4s.Header("Authorization", s"Basic $token")) } case a => sys.error("Invalid authorization scheme[" + a.getClass + "]") } val reqAndMaybeAuthAndBody = if (formBody.nonEmpty) formBody.fold(reqAndMaybeAuth)(reqAndMaybeAuth.withEntity) else body.fold(reqAndMaybeAuth)(reqAndMaybeAuth.withEntity) httpClient.fetch(modifyRequest(reqAndMaybeAuthAndBody))(handler) } } object Client { import cats.effect._ implicit def circeJsonDecoder[F[_]: Sync, A](implicit decoder: io.circe.Decoder[A]) = org.http4s.circe.jsonOf[F, A] def parseJson[F[_]: Sync, T]( className: String, r: org.http4s.Response[F] )(implicit decoder: io.circe.Decoder[T]): F[T] = r.attemptAs[T].value.flatMap { case Right(value) => Sync[F].pure(value) case Left(error) => Sync[F].raiseError(new io.apibuilder.internal.v0.errors.FailedRequest(r.status.code, s"Invalid json for class[" + className + "]", None, error)) } } sealed trait Authorization extends _root_.scala.Product with _root_.scala.Serializable object Authorization { final case class Basic(username: String, password: Option[String] = None) extends Authorization } package interfaces { trait Client[F[_]] { def baseUrl: org.http4s.Uri } } package errors { final case class FailedRequest(responseCode: Int, message: String, requestUri: Option[_root_.java.net.URI] = None, parent: Exception = null) extends _root_.java.lang.Exception(s"HTTP $responseCode: $message", parent) } }