From 7c734d179af9ca5e14834b5107d0dab12b37a656 Mon Sep 17 00:00:00 2001 From: Pavel Salamon Date: Thu, 22 Aug 2024 16:04:03 +0200 Subject: [PATCH 1/5] get partitioning additional data v2 --- ....9.6__get_partitioning_additional_data.sql | 76 +++++++++++++++++++ .../model/dto/AdditionalDataItemDTO.scala | 2 +- .../scala/za/co/absa/atum/server/Main.scala | 1 + .../controller/PartitioningController.scala | 12 ++- .../PartitioningControllerImpl.scala | 10 +++ .../GetPartitioningAdditionalDataV2.scala | 49 ++++++++++++ .../absa/atum/server/api/http/Endpoints.scala | 8 ++ .../co/absa/atum/server/api/http/Routes.scala | 4 + .../repository/PartitioningRepository.scala | 13 ++-- .../PartitioningRepositoryImpl.scala | 40 +++++----- .../api/service/PartitioningService.scala | 12 +-- .../api/service/PartitioningServiceImpl.scala | 7 ++ .../model/AdditionalDataItemFromDB.scala | 7 ++ .../za/co/absa/atum/server/api/TestData.scala | 26 ++++++- .../PartitioningControllerUnitTests.scala | 30 +++++++- ...ningAdditionalDataV2IntegrationTests.scala | 45 +++++++++++ .../PartitioningRepositoryUnitTests.scala | 44 ++++++++++- .../PartitioningServiceUnitTests.scala | 21 ++++- 18 files changed, 349 insertions(+), 58 deletions(-) create mode 100644 database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql create mode 100644 server/src/main/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2.scala create mode 100644 server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala create mode 100644 server/src/test/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2IntegrationTests.scala diff --git a/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql b/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql new file mode 100644 index 000000000..ce7973071 --- /dev/null +++ b/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql @@ -0,0 +1,76 @@ +/* + * Copyright 2021 ABSA Group Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +CREATE OR REPLACE FUNCTION runs.get_partitioning_additional_data( + IN i_partitioning_id BIGINT, + OUT status INTEGER, + OUT status_text TEXT, + OUT ad_name TEXT, + OUT ad_value TEXT, + OUT ad_author TEXT +) RETURNS SETOF record AS +$$ + ------------------------------------------------------------------------------- +-- +-- Function: runs.get_partitioning_additional_data(1) +-- Returns additional data for the given partitioning +-- +-- Parameters: +-- i_partitioning - partitioning for requested additional data +-- +-- Returns: +-- status - Status code +-- status_text - Status message +-- ad_name - Name of the additional data +-- ad_value - Value of the additional data +-- ad_author - Author of the additional data +-- +-- Status codes: +-- 11 - OK +-- 16 - No additional data found +-- 41 - Partitioning not found +-- +------------------------------------------------------------------------------- + +BEGIN + PERFORM 1 FROM runs.partitionings WHERE id_partitioning = i_partitioning_id; + IF NOT FOUND THEN + status := 41; + status_text := 'Partitioning not found'; + RETURN NEXT; + RETURN; + END IF; + + status = 11; + status_text = 'OK'; + + RETURN QUERY + SELECT status, status_text, ad.ad_name, ad.ad_value, ad.created_by + FROM runs.additional_data AS ad + WHERE ad.fk_partitioning = i_partitioning_id; + + IF NOT FOUND THEN + status := 16; + status_text := 'No additional data found'; + RETURN NEXT; + RETURN; + END IF; +END; +$$ + LANGUAGE plpgsql VOLATILE SECURITY DEFINER; + +ALTER FUNCTION runs.get_partitioning_additional_data(BIGINT) OWNER TO atum_owner; +GRANT EXECUTE ON FUNCTION runs.get_partitioning_additional_data(BIGINT) TO atum_user; diff --git a/model/src/main/scala/za/co/absa/atum/model/dto/AdditionalDataItemDTO.scala b/model/src/main/scala/za/co/absa/atum/model/dto/AdditionalDataItemDTO.scala index fa2993c53..2413d0c3a 100644 --- a/model/src/main/scala/za/co/absa/atum/model/dto/AdditionalDataItemDTO.scala +++ b/model/src/main/scala/za/co/absa/atum/model/dto/AdditionalDataItemDTO.scala @@ -20,7 +20,7 @@ import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder} import io.circe.{Decoder, Encoder} case class AdditionalDataItemDTO( - value: String, + value: Option[String], author: String ) diff --git a/server/src/main/scala/za/co/absa/atum/server/Main.scala b/server/src/main/scala/za/co/absa/atum/server/Main.scala index 32ddbf835..956f1b699 100644 --- a/server/src/main/scala/za/co/absa/atum/server/Main.scala +++ b/server/src/main/scala/za/co/absa/atum/server/Main.scala @@ -53,6 +53,7 @@ object Main extends ZIOAppDefault with Server { CreatePartitioningIfNotExists.layer, GetPartitioningMeasures.layer, GetPartitioningAdditionalData.layer, + GetPartitioningAdditionalDataV2.layer, CreateOrUpdateAdditionalData.layer, GetPartitioningCheckpoints.layer, WriteCheckpoint.layer, diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningController.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningController.scala index 2dfc53016..c6a4d6abf 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningController.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningController.scala @@ -16,13 +16,7 @@ package za.co.absa.atum.server.api.controller -import za.co.absa.atum.model.dto.{ - AdditionalDataSubmitDTO, - AtumContextDTO, - CheckpointDTO, - CheckpointQueryDTO, - PartitioningSubmitDTO -} +import za.co.absa.atum.model.dto._ import za.co.absa.atum.server.model.ErrorResponse import za.co.absa.atum.server.model.SuccessResponse.{MultiSuccessResponse, SingleSuccessResponse} import zio.IO @@ -38,6 +32,10 @@ trait PartitioningController { partitioningSubmitDTO: PartitioningSubmitDTO ): IO[ErrorResponse, SingleSuccessResponse[AtumContextDTO]] + def getPartitioningAdditionalDataV2( + partitioningId: Long + ): IO[ErrorResponse, SingleSuccessResponse[AdditionalDataDTO]] + def createOrUpdateAdditionalDataV2( additionalData: AdditionalDataSubmitDTO ): IO[ErrorResponse, SingleSuccessResponse[AdditionalDataSubmitDTO]] diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala index 6fe9efff9..88c6f03e4 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala @@ -77,6 +77,16 @@ class PartitioningControllerImpl(partitioningService: PartitioningService) ) } + override def getPartitioningAdditionalDataV2( + partitioningId: Long + ): IO[ErrorResponse, SingleSuccessResponse[AdditionalDataDTO]] = { + mapToSingleSuccessResponse( + serviceCall[AdditionalDataDTO, AdditionalDataDTO]( + partitioningService.getPartitioningAdditionalDataV2(partitioningId), + identity + ) + ) + } } object PartitioningControllerImpl { diff --git a/server/src/main/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2.scala b/server/src/main/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2.scala new file mode 100644 index 000000000..87bb45ad9 --- /dev/null +++ b/server/src/main/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2.scala @@ -0,0 +1,49 @@ +/* + * Copyright 2021 ABSA Group Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package za.co.absa.atum.server.api.database.runs.functions + +import doobie.implicits.toSqlInterpolator +import za.co.absa.atum.server.api.database.PostgresDatabaseProvider +import za.co.absa.atum.server.api.database.runs.Runs +import za.co.absa.atum.server.model.AdditionalDataItemFromDB +import za.co.absa.db.fadb.DBSchema +import za.co.absa.db.fadb.doobie.DoobieFunction.DoobieMultipleResultFunctionWithAggStatus +import za.co.absa.db.fadb.doobie.DoobieEngine +import zio.{Task, URLayer, ZIO, ZLayer} + +import za.co.absa.atum.server.api.database.DoobieImplicits.getMapWithOptionStringValues +import za.co.absa.db.fadb.doobie.postgres.circe.implicits.jsonbPut +import za.co.absa.db.fadb.status.aggregation.implementations.ByFirstErrorStatusAggregator +import za.co.absa.db.fadb.status.handling.implementations.StandardStatusHandling + +class GetPartitioningAdditionalDataV2(implicit schema: DBSchema, dbEngine: DoobieEngine[Task]) + extends DoobieMultipleResultFunctionWithAggStatus[Long, Option[AdditionalDataItemFromDB], Task](input => + Seq(fr"$input"), Some("get_partitioning_additional_data") + ) + with StandardStatusHandling + with ByFirstErrorStatusAggregator { + + override def fieldsToSelect: Seq[String] = super.fieldsToSelect ++ Seq("ad_name", "ad_value", "ad_author") +} + +object GetPartitioningAdditionalDataV2 { + val layer: URLayer[PostgresDatabaseProvider, GetPartitioningAdditionalDataV2] = ZLayer { + for { + dbProvider <- ZIO.service[PostgresDatabaseProvider] + } yield new GetPartitioningAdditionalDataV2()(Runs, dbProvider.dbEngine) + } +} diff --git a/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala b/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala index 0b79fddf6..5ac574496 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala @@ -69,6 +69,14 @@ trait Endpoints extends BaseEndpoints { .out(jsonBody[SingleSuccessResponse[AtumContextDTO]]) } + protected val getPartitioningAdditionalDataEndpointV2 + : PublicEndpoint[Long, ErrorResponse, SingleSuccessResponse[AdditionalDataDTO], Any] = { + apiV2.get + .in(V2Paths.Partitionings / path[Long]("partitioningId") / V2Paths.AdditionalData) + .out(statusCode(StatusCode.Ok)) + .out(jsonBody[SingleSuccessResponse[AdditionalDataDTO]]) + } + protected val createOrUpdateAdditionalDataEndpointV2 : PublicEndpoint[AdditionalDataSubmitDTO, ErrorResponse, SingleSuccessResponse[AdditionalDataSubmitDTO], Any] = { apiV2.post diff --git a/server/src/main/scala/za/co/absa/atum/server/api/http/Routes.scala b/server/src/main/scala/za/co/absa/atum/server/api/http/Routes.scala index 3b20484a2..c0b64d061 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/http/Routes.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/http/Routes.scala @@ -58,6 +58,10 @@ trait Routes extends Endpoints with ServerOptions { ), createServerEndpoint(createPartitioningEndpointV1, PartitioningController.createPartitioningIfNotExistsV1), createServerEndpoint(createPartitioningEndpointV2, PartitioningController.createPartitioningIfNotExistsV2), + createServerEndpoint( + getPartitioningAdditionalDataEndpointV2, + PartitioningController.getPartitioningAdditionalDataV2 + ), createServerEndpoint( createOrUpdateAdditionalDataEndpointV2, PartitioningController.createOrUpdateAdditionalDataV2 diff --git a/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepository.scala b/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepository.scala index 52e7c6c02..3d0687634 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepository.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepository.scala @@ -16,14 +16,7 @@ package za.co.absa.atum.server.api.repository -import za.co.absa.atum.model.dto.{ - InitialAdditionalDataDTO, - AdditionalDataSubmitDTO, - CheckpointQueryDTO, - MeasureDTO, - PartitioningDTO, - PartitioningSubmitDTO -} +import za.co.absa.atum.model.dto._ import za.co.absa.atum.server.api.exception.DatabaseError import za.co.absa.atum.server.model.CheckpointFromDB import zio.IO @@ -37,6 +30,10 @@ trait PartitioningRepository { def getPartitioningAdditionalData(partitioning: PartitioningDTO): IO[DatabaseError, InitialAdditionalDataDTO] + def getPartitioningAdditionalDataV2( + partitioningId: Long + ): IO[DatabaseError, AdditionalDataDTO] + def createOrUpdateAdditionalData(additionalData: AdditionalDataSubmitDTO): IO[DatabaseError, Unit] def getPartitioningCheckpoints(checkpointQueryDTO: CheckpointQueryDTO): IO[DatabaseError, Seq[CheckpointFromDB]] diff --git a/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryImpl.scala index 68ff69276..a521f785f 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryImpl.scala @@ -16,34 +16,20 @@ package za.co.absa.atum.server.api.repository -import za.co.absa.atum.model.dto.{ - InitialAdditionalDataDTO, - AdditionalDataSubmitDTO, - CheckpointQueryDTO, - MeasureDTO, - PartitioningDTO, - PartitioningSubmitDTO -} -import za.co.absa.atum.server.model.MeasureFromDB -import za.co.absa.atum.server.api.database.runs.functions.{ - CreateOrUpdateAdditionalData, - CreatePartitioningIfNotExists, - GetPartitioningAdditionalData, - GetPartitioningCheckpoints, - GetPartitioningMeasures -} +import za.co.absa.atum.model.dto._ +import za.co.absa.atum.server.model.{AdditionalDataFromDB, AdditionalDataItemFromDB, CheckpointFromDB, MeasureFromDB} +import za.co.absa.atum.server.api.database.runs.functions._ import za.co.absa.atum.server.api.exception.DatabaseError -import za.co.absa.atum.server.model.CheckpointFromDB import zio._ import zio.interop.catz.asyncInstance -import za.co.absa.atum.server.model.AdditionalDataFromDB class PartitioningRepositoryImpl( createPartitioningIfNotExistsFn: CreatePartitioningIfNotExists, getPartitioningMeasuresFn: GetPartitioningMeasures, getPartitioningAdditionalDataFn: GetPartitioningAdditionalData, createOrUpdateAdditionalDataFn: CreateOrUpdateAdditionalData, - getPartitioningCheckpointsFn: GetPartitioningCheckpoints + getPartitioningCheckpointsFn: GetPartitioningCheckpoints, + getPartitioningAdditionalDataV2Fn: GetPartitioningAdditionalDataV2 ) extends PartitioningRepository with BaseRepository { @@ -83,6 +69,15 @@ class PartitioningRepositoryImpl( ) } + override def getPartitioningAdditionalDataV2(partitioningId: Long): IO[DatabaseError, AdditionalDataDTO] = { + dbMultipleResultCallWithAggregatedStatus( + getPartitioningAdditionalDataV2Fn(partitioningId), + "getPartitioningAdditionalData" + ).map(_.collect { case Some(AdditionalDataItemFromDB(adName, adValue, author)) => + adName -> Some(AdditionalDataItemDTO(adValue, author)) + }.toMap) + .map(AdditionalDataDTO(_)) + } } object PartitioningRepositoryImpl { @@ -91,7 +86,8 @@ object PartitioningRepositoryImpl { with GetPartitioningMeasures with GetPartitioningAdditionalData with CreateOrUpdateAdditionalData - with GetPartitioningCheckpoints, + with GetPartitioningCheckpoints + with GetPartitioningAdditionalDataV2, PartitioningRepository ] = ZLayer { for { @@ -100,12 +96,14 @@ object PartitioningRepositoryImpl { getPartitioningAdditionalData <- ZIO.service[GetPartitioningAdditionalData] createOrUpdateAdditionalData <- ZIO.service[CreateOrUpdateAdditionalData] getPartitioningCheckpoints <- ZIO.service[GetPartitioningCheckpoints] + getPartitioningAdditionalDataV2 <- ZIO.service[GetPartitioningAdditionalDataV2] } yield new PartitioningRepositoryImpl( createPartitioningIfNotExists, getPartitioningMeasures, getPartitioningAdditionalData, createOrUpdateAdditionalData, - getPartitioningCheckpoints + getPartitioningCheckpoints, + getPartitioningAdditionalDataV2 ) } } diff --git a/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningService.scala b/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningService.scala index 2dce04b51..1015c692f 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningService.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningService.scala @@ -16,15 +16,7 @@ package za.co.absa.atum.server.api.service -import za.co.absa.atum.model.dto.{ - InitialAdditionalDataDTO, - AdditionalDataSubmitDTO, - CheckpointDTO, - CheckpointQueryDTO, - MeasureDTO, - PartitioningDTO, - PartitioningSubmitDTO -} +import za.co.absa.atum.model.dto._ import za.co.absa.atum.server.api.exception.ServiceError import zio.IO import zio.macros.accessible @@ -37,6 +29,8 @@ trait PartitioningService { def getPartitioningAdditionalData(partitioning: PartitioningDTO): IO[ServiceError, InitialAdditionalDataDTO] + def getPartitioningAdditionalDataV2(partitioningId: Long): IO[ServiceError, AdditionalDataDTO] + def createOrUpdateAdditionalData(additionalData: AdditionalDataSubmitDTO): IO[ServiceError, Unit] def getPartitioningCheckpoints(checkpointQueryDTO: CheckpointQueryDTO): IO[ServiceError, Seq[CheckpointDTO]] diff --git a/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningServiceImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningServiceImpl.scala index eebb7a2ba..7e75d4120 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningServiceImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/service/PartitioningServiceImpl.scala @@ -73,6 +73,13 @@ class PartitioningServiceImpl(partitioningRepository: PartitioningRepository) } yield checkpointDTOs } + + override def getPartitioningAdditionalDataV2(partitioningId: Long): IO[ServiceError, AdditionalDataDTO] = { + repositoryCall( + partitioningRepository.getPartitioningAdditionalDataV2(partitioningId), + "getPartitioningAdditionalDataV2" + ) + } } object PartitioningServiceImpl { diff --git a/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala b/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala new file mode 100644 index 000000000..6f2f529b1 --- /dev/null +++ b/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala @@ -0,0 +1,7 @@ +package za.co.absa.atum.server.model + +case class AdditionalDataItemFromDB ( + adName: String, + adValue: Option[String], + author: String, +) diff --git a/server/src/test/scala/za/co/absa/atum/server/api/TestData.scala b/server/src/test/scala/za/co/absa/atum/server/api/TestData.scala index ec94e1111..42abeaba7 100644 --- a/server/src/test/scala/za/co/absa/atum/server/api/TestData.scala +++ b/server/src/test/scala/za/co/absa/atum/server/api/TestData.scala @@ -64,18 +64,36 @@ trait TestData { protected val measureFromDB1: MeasureFromDB = MeasureFromDB(Some("count1"), Some(Seq("col_A1", "col_B1"))) protected val measureFromDB2: MeasureFromDB = MeasureFromDB(Some("count2"), Some(Seq("col_A2", "col_B2"))) - // Additional Data - protected val additionalDataDTO1: InitialAdditionalDataDTO = Map( + // Initial Additional Data + protected val initialAdditionalDataDTO1: InitialAdditionalDataDTO = Map( "key1" -> Some("value1"), "key2" -> None, "key3" -> Some("value3") ) - protected val additionalDataDTO2: InitialAdditionalDataDTO = Map( + protected val initialAdditionalDataDTO2: InitialAdditionalDataDTO = Map( "key1" -> Some("value1"), "key2" -> Some("value2"), "key3" -> Some("value3") ) - protected val additionalDataDTO3: InitialAdditionalDataDTO = Map.empty + protected val initialAdditionalDataDTO3: InitialAdditionalDataDTO = Map.empty + + protected val additionalDataDTO1: AdditionalDataDTO = AdditionalDataDTO( + Map( + "key1" -> Some(AdditionalDataItemDTO(Some("value1"), "author")), + "key2" -> None, + "key3" -> Some(AdditionalDataItemDTO(Some("value3"), "author")) + ) + ) + + protected val additionalDataDTO2: AdditionalDataDTO = AdditionalDataDTO( + Map( + "key1" -> Some(AdditionalDataItemDTO(Some("value1"), "author")), + "key2" -> Some(AdditionalDataItemDTO(Some("value2"), "author")), + "key3" -> Some(AdditionalDataItemDTO(Some("value3"), "author")) + ) + ) + + protected val additionalDataDTO3: AdditionalDataDTO = AdditionalDataDTO(Map.empty) val mainValue: TypedValue = TypedValue( value = "123", diff --git a/server/src/test/scala/za/co/absa/atum/server/api/controller/PartitioningControllerUnitTests.scala b/server/src/test/scala/za/co/absa/atum/server/api/controller/PartitioningControllerUnitTests.scala index 5bfa33121..deadc77d2 100644 --- a/server/src/test/scala/za/co/absa/atum/server/api/controller/PartitioningControllerUnitTests.scala +++ b/server/src/test/scala/za/co/absa/atum/server/api/controller/PartitioningControllerUnitTests.scala @@ -19,9 +19,9 @@ package za.co.absa.atum.server.api.controller import org.mockito.Mockito.{mock, when} import za.co.absa.atum.model.dto.CheckpointDTO import za.co.absa.atum.server.api.TestData -import za.co.absa.atum.server.api.exception.ServiceError.GeneralServiceError +import za.co.absa.atum.server.api.exception.ServiceError.{GeneralServiceError, NotFoundServiceError} import za.co.absa.atum.server.api.service.PartitioningService -import za.co.absa.atum.server.model.InternalServerErrorResponse +import za.co.absa.atum.server.model.{InternalServerErrorResponse, NotFoundErrorResponse} import za.co.absa.atum.server.model.SuccessResponse.SingleSuccessResponse import zio._ import zio.test.Assertion.{equalTo, failsWithA} @@ -53,6 +53,13 @@ object PartitioningControllerUnitTests extends ZIOSpecDefault with TestData { when(partitioningServiceMock.getPartitioningCheckpoints(checkpointQueryDTO3)) .thenReturn(ZIO.fail(GeneralServiceError("boom!"))) + when(partitioningServiceMock.getPartitioningAdditionalDataV2(1L)) + .thenReturn(ZIO.succeed(additionalDataDTO1)) + when(partitioningServiceMock.getPartitioningAdditionalDataV2(2L)) + .thenReturn(ZIO.fail(GeneralServiceError("boom!"))) + when(partitioningServiceMock.getPartitioningAdditionalDataV2(3L)) + .thenReturn(ZIO.fail(NotFoundServiceError("not found"))) + private val partitioningServiceMockLayer = ZLayer.succeed(partitioningServiceMock) override def spec: Spec[TestEnvironment with Scope, Any] = { @@ -99,6 +106,25 @@ object PartitioningControllerUnitTests extends ZIOSpecDefault with TestData { failsWithA[InternalServerErrorResponse] ) } + ), + suite("GetPartitioningAdditionalDataV2Suite")( + test("Returns expected AdditionalDataDTO") { + for { + result <- PartitioningController.getPartitioningAdditionalDataV2(1L) + expected = SingleSuccessResponse(additionalDataDTO1, uuid1) + actual = result.copy(requestId = uuid1) + } yield assertTrue(actual == expected) + }, + test("Returns expected InternalServerErrorResponse") { + assertZIO(PartitioningController.getPartitioningAdditionalDataV2(2L).exit)( + failsWithA[InternalServerErrorResponse] + ) + }, + test("Returns expected NotFoundServiceError") { + assertZIO(PartitioningController.getPartitioningAdditionalDataV2(3L).exit)( + failsWithA[NotFoundErrorResponse] + ) + } ) ).provide( PartitioningControllerImpl.layer, diff --git a/server/src/test/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2IntegrationTests.scala b/server/src/test/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2IntegrationTests.scala new file mode 100644 index 000000000..77312c3cc --- /dev/null +++ b/server/src/test/scala/za/co/absa/atum/server/api/database/runs/functions/GetPartitioningAdditionalDataV2IntegrationTests.scala @@ -0,0 +1,45 @@ +/* + * Copyright 2021 ABSA Group Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package za.co.absa.atum.server.api.database.runs.functions + +import za.co.absa.atum.model.dto.{PartitionDTO, PartitioningDTO} +import za.co.absa.atum.server.ConfigProviderTest +import za.co.absa.atum.server.api.TestTransactorProvider +import za.co.absa.atum.server.api.database.PostgresDatabaseProvider +import za.co.absa.db.fadb.exceptions.DataNotFoundException +import za.co.absa.db.fadb.status.FunctionStatus +import zio._ +import zio.interop.catz.asyncInstance +import zio.test._ + +object GetPartitioningAdditionalDataV2IntegrationTests extends ConfigProviderTest { + override def spec: Spec[TestEnvironment with Scope, Any] = { + suite("GetPartitioningAdditionalDataSuite")( + test("Returns expected sequence of Additional data with provided partitioning") { + val partitioningId: Long = 0L + for { + getPartitioningAdditionalDataV2 <- ZIO.service[GetPartitioningAdditionalDataV2] + result <- getPartitioningAdditionalDataV2(partitioningId) + } yield assertTrue(result == Left(DataNotFoundException(FunctionStatus(41, "Partitioning not found")))) + } + ).provide( + GetPartitioningAdditionalDataV2.layer, + PostgresDatabaseProvider.layer, + TestTransactorProvider.layerWithRollback + ) + } +} diff --git a/server/src/test/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryUnitTests.scala b/server/src/test/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryUnitTests.scala index c1174e3a2..0dc4a150a 100644 --- a/server/src/test/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryUnitTests.scala +++ b/server/src/test/scala/za/co/absa/atum/server/api/repository/PartitioningRepositoryUnitTests.scala @@ -17,17 +17,18 @@ package za.co.absa.atum.server.api.repository import org.mockito.Mockito.{mock, when} +import za.co.absa.atum.model.dto.{AdditionalDataDTO, AdditionalDataItemDTO} import za.co.absa.atum.server.api.TestData import za.co.absa.atum.server.api.database.runs.functions._ import za.co.absa.atum.server.api.exception.DatabaseError import za.co.absa.atum.server.api.exception.DatabaseError._ -import za.co.absa.db.fadb.exceptions.ErrorInDataException +import za.co.absa.db.fadb.exceptions.{DataNotFoundException, ErrorInDataException} import za.co.absa.db.fadb.status.{FunctionStatus, Row} import zio._ import zio.interop.catz.asyncInstance import zio.test.Assertion.failsWithA import zio.test._ -import za.co.absa.atum.server.model.AdditionalDataFromDB +import za.co.absa.atum.server.model.{AdditionalDataFromDB, AdditionalDataItemFromDB} object PartitioningRepositoryUnitTests extends ZIOSpecDefault with TestData { @@ -87,6 +88,19 @@ object PartitioningRepositoryUnitTests extends ZIOSpecDefault with TestData { private val getPartitioningCheckpointsMockLayer = ZLayer.succeed(getPartitioningCheckpointsMock) + // GetPartitioningAdditionalDataV2 + private val getPartitioningAdditionalDataV2Mock = mock(classOf[GetPartitioningAdditionalDataV2]) + + when(getPartitioningAdditionalDataV2Mock.apply(1L)).thenReturn( + ZIO.right(Seq(Row(FunctionStatus(0, "success"), Some(AdditionalDataItemFromDB("key", Some("value"), "author"))))) + ) + when(getPartitioningAdditionalDataV2Mock.apply(2L)).thenReturn(ZIO.fail(GeneralDatabaseError("boom!"))) + when(getPartitioningAdditionalDataV2Mock.apply(3L)).thenReturn( + ZIO.left(DataNotFoundException(FunctionStatus(41, "not found"))) + ) + + private val getPartitioningAdditionalDataV2MockLayer = ZLayer.succeed(getPartitioningAdditionalDataV2Mock) + override def spec: Spec[TestEnvironment with Scope, Any] = { suite("PartitioningRepositorySuite")( @@ -124,7 +138,9 @@ object PartitioningRepositoryUnitTests extends ZIOSpecDefault with TestData { result <- PartitioningRepository.createOrUpdateAdditionalData(additionalDataSubmitDTO2).exit } yield assertTrue( result == Exit.fail( - GeneralDatabaseError("Exception caused by operation: 'createOrUpdateAdditionalData': (50) error in AD data") + GeneralDatabaseError( + "Exception caused by operation: 'createOrUpdateAdditionalData': (50) error in AD data" + ) ) ) }, @@ -174,6 +190,25 @@ object PartitioningRepositoryUnitTests extends ZIOSpecDefault with TestData { result <- PartitioningRepository.getPartitioningCheckpoints(checkpointQueryDTO3) } yield assertTrue(result.isEmpty) } + ), + suite("GetPartitioningAdditionalDataV2Suite")( + test("Returns expected AdditionalDataDTO instance") { + for { + result <- PartitioningRepository.getPartitioningAdditionalDataV2(1L) + } yield assertTrue( + result == AdditionalDataDTO(Map.from(Seq("key" -> Some(AdditionalDataItemDTO(Some("value"), "author"))))) + ) + }, + test("Returns expected DatabaseError") { + assertZIO(PartitioningRepository.getPartitioningAdditionalDataV2(2L).exit)( + failsWithA[GeneralDatabaseError] + ) + }, + test("Returns expected NotFoundDatabaseError") { + assertZIO(PartitioningRepository.getPartitioningAdditionalDataV2(3L).exit)( + failsWithA[NotFoundDatabaseError] + ) + } ) ).provide( PartitioningRepositoryImpl.layer, @@ -181,7 +216,8 @@ object PartitioningRepositoryUnitTests extends ZIOSpecDefault with TestData { getPartitioningMeasuresMockLayer, getPartitioningAdditionalDataMockLayer, createOrUpdateAdditionalDataMockLayer, - getPartitioningCheckpointsMockLayer + getPartitioningCheckpointsMockLayer, + getPartitioningAdditionalDataV2MockLayer ) } diff --git a/server/src/test/scala/za/co/absa/atum/server/api/service/PartitioningServiceUnitTests.scala b/server/src/test/scala/za/co/absa/atum/server/api/service/PartitioningServiceUnitTests.scala index 0c97e1d7e..f87fa1aa3 100644 --- a/server/src/test/scala/za/co/absa/atum/server/api/service/PartitioningServiceUnitTests.scala +++ b/server/src/test/scala/za/co/absa/atum/server/api/service/PartitioningServiceUnitTests.scala @@ -48,7 +48,7 @@ object PartitioningServiceUnitTests extends ZIOSpecDefault with TestData { .thenReturn(ZIO.fail(GeneralDatabaseError("boom!"))) when(partitioningRepositoryMock.getPartitioningAdditionalData(partitioningDTO1)) - .thenReturn(ZIO.succeed(additionalDataDTO1)) + .thenReturn(ZIO.succeed(initialAdditionalDataDTO1)) when(partitioningRepositoryMock.getPartitioningAdditionalData(partitioningDTO2)) .thenReturn(ZIO.fail(GeneralDatabaseError("boom!"))) @@ -57,6 +57,11 @@ object PartitioningServiceUnitTests extends ZIOSpecDefault with TestData { when(partitioningRepositoryMock.getPartitioningCheckpoints(checkpointQueryDTO2)) .thenReturn(ZIO.fail(GeneralDatabaseError("boom!"))) + when(partitioningRepositoryMock.getPartitioningAdditionalDataV2(1L)) + .thenReturn(ZIO.succeed(additionalDataDTO1)) + when(partitioningRepositoryMock.getPartitioningAdditionalDataV2(2L)) + .thenReturn(ZIO.fail(GeneralDatabaseError("boom!"))) + private val partitioningRepositoryMockLayer = ZLayer.succeed(partitioningRepositoryMock) override def spec: Spec[TestEnvironment with Scope, Any] = { @@ -118,7 +123,7 @@ object PartitioningServiceUnitTests extends ZIOSpecDefault with TestData { test("Returns expected Right with Seq[AdditionalDataDTO]") { for { result <- PartitioningService.getPartitioningAdditionalData(partitioningDTO1) - } yield assertTrue { result == additionalDataDTO1 } + } yield assertTrue { result == initialAdditionalDataDTO1 } }, test("Returns expected ServiceError") { assertZIO(PartitioningService.getPartitioningAdditionalData(partitioningDTO2).exit)( @@ -139,6 +144,18 @@ object PartitioningServiceUnitTests extends ZIOSpecDefault with TestData { failsWithA[ServiceError] ) } + ), + suite("GetPartitioningAdditionalDataV2Suite")( + test("Returns expected Right with AdditionalDataDTO") { + for { + result <- PartitioningService.getPartitioningAdditionalDataV2(1L) + } yield assertTrue(result == additionalDataDTO1) + }, + test("Returns expected ServiceError") { + assertZIO(PartitioningService.getPartitioningAdditionalDataV2(2L).exit)( + failsWithA[ServiceError] + ) + } ) ).provide( PartitioningServiceImpl.layer, From cc91fa494fcebde06a8dda66ccf05c04ac3ddc3f Mon Sep 17 00:00:00 2001 From: Pavel Salamon Date: Fri, 23 Aug 2024 10:10:45 +0200 Subject: [PATCH 2/5] tests --- ...ningAdditionalDataV2IntegrationTests.scala | 153 ++++++++++++++++++ .../absa/atum/server/api/http/Endpoints.scala | 1 + .../model/AdditionalDataItemFromDB.scala | 16 ++ ...ingAdditionalDataV2EndpointUnitTests.scala | 72 +++++++++ 4 files changed, 242 insertions(+) create mode 100644 database/src/test/scala/za/co/absa/atum/database/runs/GetPartitioningAdditionalDataV2IntegrationTests.scala create mode 100644 server/src/test/scala/za/co/absa/atum/server/api/http/GetPartitioningAdditionalDataV2EndpointUnitTests.scala diff --git a/database/src/test/scala/za/co/absa/atum/database/runs/GetPartitioningAdditionalDataV2IntegrationTests.scala b/database/src/test/scala/za/co/absa/atum/database/runs/GetPartitioningAdditionalDataV2IntegrationTests.scala new file mode 100644 index 000000000..ca581a5e3 --- /dev/null +++ b/database/src/test/scala/za/co/absa/atum/database/runs/GetPartitioningAdditionalDataV2IntegrationTests.scala @@ -0,0 +1,153 @@ +/* + * Copyright 2021 ABSA Group Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package za.co.absa.atum.database.runs + +import za.co.absa.balta.DBTestSuite +import za.co.absa.balta.classes.JsonBString + +class GetPartitioningAdditionalDataV2IntegrationTests extends DBTestSuite { + + private val fncGetPartitioningAdditionalData = "runs.get_partitioning_additional_data" + + private val partitioning1 = JsonBString( + """ + |{ + | "version": 1, + | "keys": ["keyX", "keyY", "keyZ"], + | "keysToValues": { + | "keyX": "value1", + | "keyZ": "value3", + | "keyY": "value2" + | } + |} + |""".stripMargin + ) + + private val partitioning2 = JsonBString( + """ + |{ + | "version": 1, + | "keys": ["key1", "key3", "key2", "key4"], + | "keysToValues": { + | "key1": "valueX", + | "key2": "valueY", + | "key3": "valueZ", + | "key4": "valueA" + | } + |} + |""".stripMargin + ) + + test("Get partitioning additional data returns additional data for partitioning with additional data") { + table("runs.partitionings").insert( + add("partitioning", partitioning1) + .add("created_by", "Joseph") + ) + + table("runs.partitionings").insert( + add("partitioning", partitioning2) + .add("created_by", "Daniel") + ) + + val fkPartitioning1: Long = table("runs.partitionings").fieldValue("partitioning", partitioning1, "id_partitioning").get.get + val fkPartitioning2: Long = table("runs.partitionings").fieldValue("partitioning", partitioning2, "id_partitioning").get.get + + table("runs.additional_data").insert( + add("fk_partitioning", fkPartitioning1) + .add("created_by", "Joseph") + .add("ad_name", "ad_1") + .add("ad_value", "This is the additional data for Joseph") + ) + + table("runs.additional_data").insert( + add("fk_partitioning", fkPartitioning1) + .add("created_by", "Joseph") + .add("ad_name", "ad_2") + .add("ad_value", "This is the additional data for Joseph") + ) + + table("runs.additional_data").insert( + add("fk_partitioning", fkPartitioning2) + .add("created_by", "Daniel") + .add("ad_name", "ad_3") + .add("ad_value", "This is the additional data for Daniel") + ) + + function(fncGetPartitioningAdditionalData) + .setParam("i_partitioning_id", fkPartitioning1) + .execute { queryResult => + val results = queryResult.next() + assert(results.getInt("status").contains(11)) + assert(results.getString("status_text").contains("OK")) + assert(results.getString("ad_name").contains("ad_1")) + assert(results.getString("ad_value").contains("This is the additional data for Joseph")) + assert(results.getString("ad_author").contains("Joseph")) + + val results2 = queryResult.next() + assert(results2.getInt("status").contains(11)) + assert(results2.getString("status_text").contains("OK")) + assert(results2.getString("ad_name").contains("ad_2")) + assert(results2.getString("ad_value").contains("This is the additional data for Joseph")) + assert(results2.getString("ad_author").contains("Joseph")) + + assert(!queryResult.hasNext) + } + + table("runs.additional_data").where(add("fk_partitioning", fkPartitioning1)) { additionalDataResult => + assert(additionalDataResult.hasNext) + val row = additionalDataResult.next() + assert(row.getString("ad_name").contains("ad_1")) + assert(row.getString("ad_value").contains("This is the additional data for Joseph")) + assert(row.getString("created_by").contains("Joseph")) + } + + } + + test("Get partitioning additional data should return no records for partitioning without additional data") { + table("runs.partitionings").insert( + add("partitioning", partitioning2) + .add("created_by", "Joseph") + ) + + val fkPartitioning: Long = table("runs.partitionings").fieldValue("partitioning", partitioning2, "id_partitioning").get.get + + function(fncGetPartitioningAdditionalData) + .setParam("i_partitioning_id", fkPartitioning) + .execute { queryResult => + val result = queryResult.next() + assert(result.getInt("status").contains(16)) + assert(result.getString("status_text").contains("No additional data found")) + assert(!queryResult.hasNext) + } + + table("runs.additional_data").where(add("fk_partitioning", fkPartitioning)) { additionalDataResult => + assert(!additionalDataResult.hasNext) + } + } + + test("Get partitioning additional data should return error status code on non existing partitioning") { + function(fncGetPartitioningAdditionalData) + .setParam("i_partitioning_id", 0L) + .execute { queryResult => + val results = queryResult.next() + assert(results.getInt("status").contains(41)) + assert(results.getString("status_text").contains("Partitioning not found")) + assert(!queryResult.hasNext) + } + } + +} diff --git a/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala b/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala index 5ac574496..0ec3ab8f5 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/http/Endpoints.scala @@ -75,6 +75,7 @@ trait Endpoints extends BaseEndpoints { .in(V2Paths.Partitionings / path[Long]("partitioningId") / V2Paths.AdditionalData) .out(statusCode(StatusCode.Ok)) .out(jsonBody[SingleSuccessResponse[AdditionalDataDTO]]) + .errorOutVariantPrepend(notFoundErrorOneOfVariant) } protected val createOrUpdateAdditionalDataEndpointV2 diff --git a/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala b/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala index 6f2f529b1..2f86ea78c 100644 --- a/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala +++ b/server/src/main/scala/za/co/absa/atum/server/model/AdditionalDataItemFromDB.scala @@ -1,3 +1,19 @@ +/* + * Copyright 2021 ABSA Group Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package za.co.absa.atum.server.model case class AdditionalDataItemFromDB ( diff --git a/server/src/test/scala/za/co/absa/atum/server/api/http/GetPartitioningAdditionalDataV2EndpointUnitTests.scala b/server/src/test/scala/za/co/absa/atum/server/api/http/GetPartitioningAdditionalDataV2EndpointUnitTests.scala new file mode 100644 index 000000000..3c500f787 --- /dev/null +++ b/server/src/test/scala/za/co/absa/atum/server/api/http/GetPartitioningAdditionalDataV2EndpointUnitTests.scala @@ -0,0 +1,72 @@ +package za.co.absa.atum.server.api.http + +import org.mockito.Mockito.{mock, when} +import sttp.client3._ +import sttp.client3.circe.asJson +import sttp.client3.testing.SttpBackendStub +import sttp.model.StatusCode +import sttp.tapir.server.stub.TapirStubInterpreter +import sttp.tapir.ztapir.{RIOMonadError, RichZEndpoint} +import za.co.absa.atum.model.dto.AdditionalDataDTO +import za.co.absa.atum.server.api.TestData +import za.co.absa.atum.server.api.controller.PartitioningController +import za.co.absa.atum.server.model.NotFoundErrorResponse +import za.co.absa.atum.server.model.SuccessResponse.SingleSuccessResponse +import zio._ +import zio.test.Assertion.equalTo +import zio.test._ + +object GetPartitioningAdditionalDataV2EndpointUnitTests extends ZIOSpecDefault with Endpoints with TestData { + + private val partitioningControllerMock = mock(classOf[PartitioningController]) + + when(partitioningControllerMock.getPartitioningAdditionalDataV2(1L)) + .thenReturn(ZIO.succeed(SingleSuccessResponse(additionalDataDTO1, uuid1))) + when(partitioningControllerMock.getPartitioningAdditionalDataV2(2L)) + .thenReturn(ZIO.fail(NotFoundErrorResponse("partitioning not found"))) + + private val partitioningControllerMockLayer = ZLayer.succeed(partitioningControllerMock) + + private val getPartitioningAdditionalDataServerEndpointV2 = getPartitioningAdditionalDataEndpointV2 + .zServerLogic({ partitioningId: Long => + PartitioningController.getPartitioningAdditionalDataV2(partitioningId) + }) + + override def spec: Spec[TestEnvironment with Scope, Any] = { + + val backendStub = TapirStubInterpreter(SttpBackendStub.apply(new RIOMonadError[PartitioningController])) + .whenServerEndpoint(getPartitioningAdditionalDataServerEndpointV2) + .thenRunLogic() + .backend() + + suite("GetPartitioningAdditionalDataV2EndpointSuite")( + test("Returns an expected AdditionalDataDTO") { + val request = basicRequest + .get(uri"https://test.com/api/v2/partitionings/1/additional-data") + .response(asJson[SingleSuccessResponse[AdditionalDataDTO]]) + + val response = request + .send(backendStub) + + val body = response.map(_.body) + val statusCode = response.map(_.code) + + assertZIO(body <&> statusCode)( + equalTo(Right(SingleSuccessResponse(additionalDataDTO1, uuid1)), StatusCode.Ok) + ) + }, + test("Returns expected 404 when partitioning not found for a given id") { + val request = basicRequest + .get(uri"https://test.com/api/v2/partitionings/2/additional-data") + .response(asJson[NotFoundErrorResponse]) + + val response = request + .send(backendStub) + + val statusCode = response.map(_.code) + + assertZIO(statusCode)(equalTo(StatusCode.NotFound)) + } + ) + }.provide(partitioningControllerMockLayer) +} From 9f0cb0bd463a5dc36bbed90084d91504e2c171a5 Mon Sep 17 00:00:00 2001 From: salamonpavel Date: Mon, 26 Aug 2024 12:42:09 +0200 Subject: [PATCH 3/5] Update database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql Co-authored-by: David Benedeki <14905969+benedeki@users.noreply.github.com> --- .../postgres/runs/V1.9.6__get_partitioning_additional_data.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql b/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql index ce7973071..cb3cf878d 100644 --- a/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql +++ b/database/src/main/postgres/runs/V1.9.6__get_partitioning_additional_data.sql @@ -29,7 +29,7 @@ $$ -- Returns additional data for the given partitioning -- -- Parameters: --- i_partitioning - partitioning for requested additional data +-- i_partitioning_id - id of the partitioning for requested additional data -- -- Returns: -- status - Status code From 8abcddc143b20164847c5cb06ee8a3aab3fcd7fc Mon Sep 17 00:00:00 2001 From: Pavel Salamon Date: Mon, 26 Aug 2024 12:52:10 +0200 Subject: [PATCH 4/5] identity as default onSuccessFnc --- .../co/absa/atum/server/api/controller/BaseController.scala | 2 +- .../server/api/controller/PartitioningControllerImpl.scala | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/BaseController.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/BaseController.scala index 78ff611e6..0dedb25e8 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/BaseController.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/BaseController.scala @@ -28,7 +28,7 @@ trait BaseController { def serviceCall[A, B]( serviceCall: IO[ServiceError, A], - onSuccessFnc: A => B + onSuccessFnc: A => B = identity[A] _ ): IO[ErrorResponse, B] = { serviceCall diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala index 88c6f03e4..c54654b15 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/PartitioningControllerImpl.scala @@ -71,8 +71,7 @@ class PartitioningControllerImpl(partitioningService: PartitioningService) ): IO[ErrorResponse, MultiSuccessResponse[CheckpointDTO]] = { mapToMultiSuccessResponse( serviceCall[Seq[CheckpointDTO], Seq[CheckpointDTO]]( - partitioningService.getPartitioningCheckpoints(checkpointQueryDTO), - identity + partitioningService.getPartitioningCheckpoints(checkpointQueryDTO) ) ) } @@ -82,8 +81,7 @@ class PartitioningControllerImpl(partitioningService: PartitioningService) ): IO[ErrorResponse, SingleSuccessResponse[AdditionalDataDTO]] = { mapToSingleSuccessResponse( serviceCall[AdditionalDataDTO, AdditionalDataDTO]( - partitioningService.getPartitioningAdditionalDataV2(partitioningId), - identity + partitioningService.getPartitioningAdditionalDataV2(partitioningId) ) ) } From 33f29e57920f9df41d3825383014cd73e460df94 Mon Sep 17 00:00:00 2001 From: Pavel Salamon Date: Mon, 26 Aug 2024 12:53:00 +0200 Subject: [PATCH 5/5] identity as default onSuccessFnc --- .../atum/server/api/controller/CheckpointControllerImpl.scala | 3 +-- .../absa/atum/server/api/controller/FlowControllerImpl.scala | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/CheckpointControllerImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/CheckpointControllerImpl.scala index fce02274e..9cbd50391 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/CheckpointControllerImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/CheckpointControllerImpl.scala @@ -59,8 +59,7 @@ class CheckpointControllerImpl(checkpointService: CheckpointService) extends Che ): IO[ErrorResponse, SingleSuccessResponse[CheckpointV2DTO]] = { mapToSingleSuccessResponse( serviceCall[CheckpointV2DTO, CheckpointV2DTO]( - checkpointService.getCheckpointV2(partitioningId, checkpointId), - identity + checkpointService.getCheckpointV2(partitioningId, checkpointId) ) ) } diff --git a/server/src/main/scala/za/co/absa/atum/server/api/controller/FlowControllerImpl.scala b/server/src/main/scala/za/co/absa/atum/server/api/controller/FlowControllerImpl.scala index 8382b212c..a677232ea 100644 --- a/server/src/main/scala/za/co/absa/atum/server/api/controller/FlowControllerImpl.scala +++ b/server/src/main/scala/za/co/absa/atum/server/api/controller/FlowControllerImpl.scala @@ -29,8 +29,7 @@ class FlowControllerImpl(flowService: FlowService) extends FlowController with B ): IO[ErrorResponse, MultiSuccessResponse[CheckpointDTO]] = { mapToMultiSuccessResponse( serviceCall[Seq[CheckpointDTO], Seq[CheckpointDTO]]( - flowService.getFlowCheckpoints(checkpointQueryDTO), - identity + flowService.getFlowCheckpoints(checkpointQueryDTO) ) ) }