Add Transformations Schedules

Author: Stanislav Lukeš

src/main/scala/com/cognite/sdk/scala/common/dataTypes.scala

@@ -5,7 +5,7 @@ package com.cognite.sdk.scala.common
 
 import java.time.Instant
 import cats.Id
-import com.cognite.sdk.scala.v1.CogniteId
+import com.cognite.sdk.scala.v1.{CogniteExternalId, CogniteId, CogniteInternalId}
 import io.circe.{Decoder, Encoder, Json, JsonObject}
 import io.circe.generic.semiauto.deriveDecoder
 import sttp.model.Uri
@@ -96,7 +96,28 @@ final case class CdpApiException(
       ).flatMap(_.toList).mkString
 
       s"Request ${maybeId}to ${url.toString} failed with status ${code.toString}: $message.$details"
-    })
+    }) {
+  def missingIds: Seq[CogniteId] =
+    missing.getOrElse(Seq.empty).flatMap(CdpApiException.decodeId)
+  def missingExternalIds: Seq[String] =
+    missingIds.collect { case CogniteExternalId(externalId) =>
+      externalId
+    }
+  def missingInternalIds: Seq[Long] =
+    missingIds.collect { case CogniteInternalId(id) =>
+      id
+    }
+  def duplicatedIds: Seq[CogniteId] =
+    duplicated.getOrElse(Seq.empty).flatMap(CdpApiException.decodeId)
+  def duplicatedExternalIds: Seq[String] =
+    duplicatedIds.collect { case CogniteExternalId(externalId) =>
+      externalId
+    }
+  def duplicatedInternalIds: Seq[Long] =
+    duplicatedIds.collect { case CogniteInternalId(id) =>
+      id
+    }
+}
 
 object CdpApiException {
   private def describeErrorList(kind: String)(items: Seq[JsonObject]): String =
@@ -120,6 +141,19 @@ object CdpApiException {
         s" $kind ${key}s: [$commaSeparatedValues]."
       }
       .mkString
+
+  private val externalIdDecoder: Decoder[CogniteExternalId] = deriveDecoder
+  private val internalIdDecoder: Decoder[CogniteInternalId] = deriveDecoder
+  private def decodeId(jsonObject: JsonObject): Option[CogniteId] = {
+    val json = Json.fromJsonObject(jsonObject)
+    internalIdDecoder.decodeJson(json) match {
+      case Right(id: CogniteId) => Some(id)
+      case _ => externalIdDecoder.decodeJson(json) match {
+        case Right(id) => Some(id)
+        case _ => None
+      }
+    }
+  }
 }
 
 final case class DataPoint(

src/main/scala/com/cognite/sdk/scala/v1/resources/transformations.scala

@@ -25,6 +25,8 @@ class Transformations[F[_]: Monad](val requestSession: RequestSession[F])
   import Transformations._
   override val baseUrl = uri"${requestSession.baseUrl}/transformations"
 
+  val schedules: TransformationSchedules[F] = new TransformationSchedules[F](requestSession)
+
   override private[sdk] def readWithCursor(
       cursor: Option[String],
       limit: Option[Int],
@@ -62,12 +64,24 @@ class Transformations[F[_]: Monad](val requestSession: RequestSession[F])
     )
 
   override def createItems(items: Items[TransformConfigCreate]): F[Seq[TransformConfigRead]] =
-    Create.createItems[F, TransformConfigRead, TransformConfigCreate](requestSession, baseUrl, items)
+    Create.createItems[F, TransformConfigRead, TransformConfigCreate](
+      requestSession,
+      baseUrl,
+      items
+    )
 
-  override def updateById(items: Map[Long, StandardTransformConfigUpdate]): F[Seq[TransformConfigRead]] =
-    UpdateById.updateById[F, TransformConfigRead, StandardTransformConfigUpdate](requestSession, baseUrl, items)
+  override def updateById(
+      items: Map[Long, StandardTransformConfigUpdate]
+  ): F[Seq[TransformConfigRead]] =
+    UpdateById.updateById[F, TransformConfigRead, StandardTransformConfigUpdate](
+      requestSession,
+      baseUrl,
+      items
+    )
 
-  override def updateByExternalId(items: Map[String, StandardTransformConfigUpdate]): F[Seq[TransformConfigRead]] =
+  override def updateByExternalId(
+      items: Map[String, StandardTransformConfigUpdate]
+  ): F[Seq[TransformConfigRead]] =
     UpdateByExternalId.updateByExternalId[F, TransformConfigRead, StandardTransformConfigUpdate](
       requestSession,
       baseUrl,
@@ -79,21 +93,6 @@ class Transformations[F[_]: Monad](val requestSession: RequestSession[F])
   override def deleteByIds(ids: Seq[Long], ignoreUnknownIds: Boolean): F[Unit] =
     DeleteByIds.deleteByIdsWithIgnoreUnknownIds(requestSession, baseUrl, ids, ignoreUnknownIds)
 
-  def deleteByIds(
-      ids: Seq[Long],
-      recursive: Boolean,
-      ignoreUnknownIds: Boolean
-  ): F[Unit] =
-    requestSession.post[Unit, Unit, ItemsWithRecursiveAndIgnoreUnknownIds](
-      ItemsWithRecursiveAndIgnoreUnknownIds(
-        ids.map(CogniteInternalId.apply),
-        recursive,
-        ignoreUnknownIds
-      ),
-      uri"$baseUrl/delete",
-      _ => ()
-    )
-
   override def deleteByExternalIds(externalIds: Seq[String]): F[Unit] =
     deleteByExternalIds(externalIds, false)
 
@@ -105,28 +104,12 @@ class Transformations[F[_]: Monad](val requestSession: RequestSession[F])
       ignoreUnknownIds
     )
 
-  def deleteByExternalIds(
-      externalIds: Seq[String],
-      recursive: Boolean,
-      ignoreUnknownIds: Boolean
-  ): F[Unit] =
-    requestSession.post[Unit, Unit, ItemsWithRecursiveAndIgnoreUnknownIds](
-      ItemsWithRecursiveAndIgnoreUnknownIds(
-        externalIds.map(CogniteExternalId.apply),
-        recursive,
-        ignoreUnknownIds
-      ),
-      uri"$baseUrl/delete",
-      _ => ()
-    )
-
-
   def query[I](
       query: String,
       limit: Int = 1000
   )(implicit itemDecoder: Decoder[I]): F[QueryResponse[I]] = {
     implicit val responseItemsDecoder: Decoder[Items[I]] = deriveDecoder[Items[I]]
-    responseItemsDecoder.hashCode // suppress no usage warning... 🤦
+    val _ = itemDecoder.hashCode + responseItemsDecoder.hashCode // suppress no usage warnings... 🤦
     implicit val responseDecoder: Decoder[QueryResponse[I]] = deriveDecoder[QueryResponse[I]]
     requestSession.post[QueryResponse[I], QueryResponse[I], QueryQuery](
       QueryQuery(query),
@@ -135,6 +118,7 @@ class Transformations[F[_]: Monad](val requestSession: RequestSession[F])
     )
   }
 
+  @SuppressWarnings(Array("org.wartremover.warts.TraversableOps"))
   def queryOne[I](
       q: String
   )(implicit itemDecoder: Decoder[I]): F[I] =
@@ -148,8 +132,10 @@ object Transformations {
   implicit val readItemsDecoder: Decoder[Items[TransformConfigRead]] =
     deriveDecoder[Items[TransformConfigRead]]
   implicit val createEncoder: Encoder[TransformConfigCreate] = deriveEncoder[TransformConfigCreate]
-  implicit val createItemsEncoder: Encoder[Items[TransformConfigCreate]] = deriveEncoder[Items[TransformConfigCreate]]
-  implicit val updateEncoder: Encoder[StandardTransformConfigUpdate] = deriveEncoder[StandardTransformConfigUpdate]
+  implicit val createItemsEncoder: Encoder[Items[TransformConfigCreate]] =
+    deriveEncoder[Items[TransformConfigCreate]]
+  implicit val updateEncoder: Encoder[StandardTransformConfigUpdate] =
+    deriveEncoder[StandardTransformConfigUpdate]
 
   implicit val errorOrUnitDecoder: Decoder[Either[CdpApiError, Unit]] =
     EitherDecoder.eitherDecoder[CdpApiError, Unit]
@@ -161,5 +147,101 @@ object Transformations {
   implicit val queryEncoder: Encoder[QueryQuery] =
     deriveEncoder[QueryQuery]
   implicit val querySchemaDecoder: Decoder[QuerySchemaColumn] = deriveDecoder[QuerySchemaColumn]
-  implicit val querySchemaItemsDecoder: Decoder[Items[QuerySchemaColumn]] = deriveDecoder[Items[QuerySchemaColumn]]
+  implicit val querySchemaItemsDecoder: Decoder[Items[QuerySchemaColumn]] =
+    deriveDecoder[Items[QuerySchemaColumn]]
+}
+
+class TransformationSchedules[F[_]](val requestSession: RequestSession[F])
+    extends WithRequestSession[F]
+    with Create[TransformationScheduleRead, TransformationScheduleCreate, F]
+    with RetrieveByIdsWithIgnoreUnknownIds[TransformationScheduleRead, F]
+    with Readable[TransformationScheduleRead, F]
+    with RetrieveByExternalIdsWithIgnoreUnknownIds[TransformationScheduleRead, F]
+    with DeleteByIdsWithIgnoreUnknownIds[F, Long]
+    with DeleteByExternalIdsWithIgnoreUnknownIds[F]
+    //with UpdateById[TransformConfigRead, StandardTransformConfigUpdate, F]
+    //with UpdateByExternalId[TransformConfigRead, StandardTransformConfigUpdate, F]
+    {
+  import TransformationSchedules._
+  override val baseUrl = uri"${requestSession.baseUrl}/transformations/schedules"
+
+  override private[sdk] def readWithCursor(
+      cursor: Option[String],
+      limit: Option[Int],
+      partition: Option[Partition]
+  ): F[ItemsWithCursor[TransformationScheduleRead]] =
+    Readable.readWithCursor(
+      requestSession,
+      baseUrl,
+      cursor,
+      limit,
+      partition,
+      100
+    )
+
+  override def retrieveByIds(
+      ids: Seq[Long],
+      ignoreUnknownIds: Boolean
+  ): F[Seq[TransformationScheduleRead]] =
+    RetrieveByIdsWithIgnoreUnknownIds.retrieveByIds(
+      requestSession,
+      baseUrl,
+      ids,
+      ignoreUnknownIds
+    )
+
+  override def retrieveByExternalIds(
+      externalIds: Seq[String],
+      ignoreUnknownIds: Boolean
+  ): F[Seq[TransformationScheduleRead]] =
+    RetrieveByExternalIdsWithIgnoreUnknownIds.retrieveByExternalIds(
+      requestSession,
+      baseUrl,
+      externalIds,
+      ignoreUnknownIds
+    )
+
+  override def createItems(
+      items: Items[TransformationScheduleCreate]
+  ): F[Seq[TransformationScheduleRead]] =
+    Create.createItems[F, TransformationScheduleRead, TransformationScheduleCreate](
+      requestSession,
+      baseUrl,
+      items
+    )
+
+  override def deleteByIds(ids: Seq[Long]): F[Unit] = deleteByIds(ids, false)
+
+  override def deleteByIds(ids: Seq[Long], ignoreUnknownIds: Boolean): F[Unit] =
+    DeleteByIds.deleteByIdsWithIgnoreUnknownIds(requestSession, baseUrl, ids, ignoreUnknownIds)
+
+  override def deleteByExternalIds(externalIds: Seq[String]): F[Unit] =
+    deleteByExternalIds(externalIds, false)
+
+  override def deleteByExternalIds(externalIds: Seq[String], ignoreUnknownIds: Boolean): F[Unit] =
+    DeleteByExternalIds.deleteByExternalIdsWithIgnoreUnknownIds(
+      requestSession,
+      baseUrl,
+      externalIds,
+      ignoreUnknownIds
+    )
+}
+
+object TransformationSchedules {
+  implicit val readDecoder: Decoder[TransformationScheduleRead] =
+    deriveDecoder[TransformationScheduleRead]
+  implicit val readItemsWithCursorDecoder: Decoder[ItemsWithCursor[TransformationScheduleRead]] =
+    deriveDecoder[ItemsWithCursor[TransformationScheduleRead]]
+  implicit val readItemsDecoder: Decoder[Items[TransformationScheduleRead]] =
+    deriveDecoder[Items[TransformationScheduleRead]]
+  implicit val createEncoder: Encoder[TransformationScheduleCreate] =
+    deriveEncoder[TransformationScheduleCreate]
+  implicit val createItemsEncoder: Encoder[Items[TransformationScheduleCreate]] =
+    deriveEncoder[Items[TransformationScheduleCreate]]
+  //implicit val updateEncoder: Encoder[StandardTransformConfigUpdate] = deriveEncoder[StandardTransformConfigUpdate]
+
+  implicit val errorOrUnitDecoder: Decoder[Either[CdpApiError, Unit]] =
+    EitherDecoder.eitherDecoder[CdpApiError, Unit]
+  implicit val cogniteExternalIdDecoder: Decoder[CogniteExternalId] =
+    deriveDecoder[CogniteExternalId]
 }