[PM-34822] Consistent error response 400 and 404 in Org Integrations controller (#7458)

voommen-livefront · web-flow · commit dcc685da1653 · 2026-04-25T11:57:18.000-05:00
diff --git a/src/Api/Dirt/Controllers/OrganizationIntegrationController.cs b/src/Api/Dirt/Controllers/OrganizationIntegrationController.cs
@@ -2,7 +2,6 @@
 using Bit.Api.Dirt.Models.Response;
 using Bit.Core.Context;
 using Bit.Core.Dirt.EventIntegrations.OrganizationIntegrations.Interfaces;
-using Bit.Core.Exceptions;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
@@ -18,17 +17,17 @@ public class OrganizationIntegrationController(
     IGetOrganizationIntegrationsQuery getQuery) : Controller
 {
     [HttpGet("")]
-    public async Task<List<OrganizationIntegrationResponseModel>> GetAsync(Guid organizationId)
+    public async Task<ActionResult<List<OrganizationIntegrationResponseModel>>> GetAsync(Guid organizationId)
     {
         if (!await HasPermission(organizationId))
         {
-            throw new NotFoundException();
+            return NotFound();
         }
 
         var integrations = await getQuery.GetManyByOrganizationAsync(organizationId);
-        return integrations
+        return Ok(integrations
             .Select(integration => new OrganizationIntegrationResponseModel(integration))
-            .ToList();
+            .ToList());
     }
 
     /// <summary>
@@ -38,7 +37,7 @@ public async Task<List<OrganizationIntegrationResponseModel>> GetAsync(Guid orga
     /// <param name="organizationId"></param>
     /// <param name="model"></param>
     /// <returns></returns>
-    /// <exception cref="NotFoundException">Not enough permissions to access the organization.</exception>
+    /// <exception cref="NotFoundResult">Not enough permissions to access the organization.</exception>
     /// <exception cref="ConflictResult">When an integration of the same type already exists for the organization.</exception>
     [HttpPost("")]
     public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsync(Guid organizationId, [FromBody] OrganizationIntegrationRequestModel model)
@@ -50,7 +49,7 @@ public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsyn
 
         if (!await HasPermission(organizationId))
         {
-            throw new NotFoundException();
+            return NotFound();
         }
 
         var integration = model.ToOrganizationIntegration(organizationId);
@@ -62,40 +61,40 @@ public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsyn
         }
 
         var created = await createCommand.CreateAsync(integration);
-
         return Ok(new OrganizationIntegrationResponseModel(created));
+
     }
 
     [HttpPut("{integrationId:guid}")]
-    public async Task<OrganizationIntegrationResponseModel> UpdateAsync(Guid organizationId, Guid integrationId, [FromBody] OrganizationIntegrationRequestModel model)
+    public async Task<ActionResult<OrganizationIntegrationResponseModel>> UpdateAsync(Guid organizationId, Guid integrationId, [FromBody] OrganizationIntegrationRequestModel model)
     {
         if (!await HasPermission(organizationId))
         {
-            throw new NotFoundException();
+            return NotFound();
         }
 
         var integration = model.ToOrganizationIntegration(organizationId);
         var updated = await updateCommand.UpdateAsync(organizationId, integrationId, integration);
-
-        return new OrganizationIntegrationResponseModel(updated);
+        return Ok(new OrganizationIntegrationResponseModel(updated));
     }
 
     [HttpDelete("{integrationId:guid}")]
-    public async Task DeleteAsync(Guid organizationId, Guid integrationId)
+    public async Task<IActionResult> DeleteAsync(Guid organizationId, Guid integrationId)
     {
         if (!await HasPermission(organizationId))
         {
-            throw new NotFoundException();
+            return NotFound();
         }
 
         await deleteCommand.DeleteAsync(organizationId, integrationId);
+        return NoContent();
     }
 
     [HttpPost("{integrationId:guid}/delete")]
     [Obsolete("This endpoint is deprecated. Use DELETE method instead")]
-    public async Task PostDeleteAsync(Guid organizationId, Guid integrationId)
+    public async Task<IActionResult> PostDeleteAsync(Guid organizationId, Guid integrationId)
     {
-        await DeleteAsync(organizationId, integrationId);
+        return await DeleteAsync(organizationId, integrationId);
     }
 
     private async Task<bool> HasPermission(Guid organizationId)
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/CreateOrganizationIntegrationConfigurationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/CreateOrganizationIntegrationConfigurationCommand.cs
@@ -27,7 +27,7 @@ public async Task<OrganizationIntegrationConfiguration> CreateAsync(
         var integration = await integrationRepository.GetByIdAsync(integrationId);
         if (integration == null || integration.OrganizationId != organizationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException();
         }
         if (!validator.ValidateConfiguration(integration.Type, configuration))
         {
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/DeleteOrganizationIntegrationConfigurationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/DeleteOrganizationIntegrationConfigurationCommand.cs
@@ -21,12 +21,12 @@ public async Task DeleteAsync(Guid organizationId, Guid integrationId, Guid conf
         var integration = await integrationRepository.GetByIdAsync(integrationId);
         if (integration == null || integration.OrganizationId != organizationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Integration not found for this organization.");
         }
         var configuration = await configurationRepository.GetByIdAsync(configurationId);
         if (configuration is null || configuration.OrganizationIntegrationId != integrationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Configuration not found for this integration.");
         }
 
         await configurationRepository.DeleteAsync(configuration);
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/Interfaces/ICreateOrganizationIntegrationConfigurationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/Interfaces/ICreateOrganizationIntegrationConfigurationCommand.cs
@@ -14,7 +14,7 @@ public interface ICreateOrganizationIntegrationConfigurationCommand
     /// <param name="integrationId">The unique identifier of the integration.</param>
     /// <param name="configuration">The configuration to create.</param>
     /// <returns>The created configuration.</returns>
-    /// <exception cref="Exceptions.NotFoundException">Thrown when the integration does not exist
+    /// <exception cref="Exceptions.BadRequestException">Thrown when the integration does not exist
     /// or does not belong to the specified organization.</exception>
     /// <exception cref="Exceptions.BadRequestException">Thrown when the configuration or filters
     /// are invalid for the integration type.</exception>
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/Interfaces/IUpdateOrganizationIntegrationConfigurationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/Interfaces/IUpdateOrganizationIntegrationConfigurationCommand.cs
@@ -15,7 +15,7 @@ public interface IUpdateOrganizationIntegrationConfigurationCommand
     /// <param name="configurationId">The unique identifier of the configuration to update.</param>
     /// <param name="updatedConfiguration">The updated configuration data.</param>
     /// <returns>The updated configuration.</returns>
-    /// <exception cref="Exceptions.NotFoundException">
+    /// <exception cref="Exceptions.BadRequestException">Thrown when the integration or the configuration does not exist,
     /// Thrown when the integration or the configuration does not exist,
     /// or the integration does not belong to the specified organization,
     /// or the configuration does not belong to the specified integration.</exception>
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/UpdateOrganizationIntegrationConfigurationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/UpdateOrganizationIntegrationConfigurationCommand.cs
@@ -28,12 +28,12 @@ public async Task<OrganizationIntegrationConfiguration> UpdateAsync(
         var integration = await integrationRepository.GetByIdAsync(integrationId);
         if (integration == null || integration.OrganizationId != organizationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Integration not found for this organization.");
         }
         var configuration = await configurationRepository.GetByIdAsync(configurationId);
         if (configuration is null || configuration.OrganizationIntegrationId != integrationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Configuration not found for this integration.");
         }
         if (!validator.ValidateConfiguration(integration.Type, updatedConfiguration))
         {
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/DeleteOrganizationIntegrationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/DeleteOrganizationIntegrationCommand.cs
@@ -20,7 +20,7 @@ public async Task DeleteAsync(Guid organizationId, Guid integrationId)
         var integration = await integrationRepository.GetByIdAsync(integrationId);
         if (integration is null || integration.OrganizationId != organizationId)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Integration not found for this organization.");
         }
 
         await integrationRepository.DeleteAsync(integration);
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/Interfaces/IDeleteOrganizationIntegrationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/Interfaces/IDeleteOrganizationIntegrationCommand.cs
@@ -10,7 +10,7 @@ public interface IDeleteOrganizationIntegrationCommand
     /// </summary>
     /// <param name="organizationId">The unique identifier of the organization.</param>
     /// <param name="integrationId">The unique identifier of the integration to delete.</param>
-    /// <exception cref="Exceptions.NotFoundException">Thrown when the integration does not exist
+    /// <exception cref="Exceptions.BadRequestException">Thrown when the integration does not exist
     /// or does not belong to the specified organization.</exception>
     Task DeleteAsync(Guid organizationId, Guid integrationId);
 }
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/Interfaces/IUpdateOrganizationIntegrationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/Interfaces/IUpdateOrganizationIntegrationCommand.cs
@@ -14,7 +14,7 @@ public interface IUpdateOrganizationIntegrationCommand
     /// <param name="integrationId">The unique identifier of the integration to update.</param>
     /// <param name="updatedIntegration">The updated organization integration data.</param>
     /// <returns>The updated organization integration.</returns>
-    /// <exception cref="Exceptions.NotFoundException">Thrown when the integration does not exist,
+    /// <exception cref="Exceptions.BadRequestException">Thrown when the integration does not exist,
     /// does not belong to the specified organization, or the integration type does not match.</exception>
     Task<OrganizationIntegration> UpdateAsync(Guid organizationId, Guid integrationId, OrganizationIntegration updatedIntegration);
 }
diff --git a/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/UpdateOrganizationIntegrationCommand.cs b/src/Core/Dirt/EventIntegrations/OrganizationIntegrations/UpdateOrganizationIntegrationCommand.cs
@@ -27,7 +27,7 @@ public async Task<OrganizationIntegration> UpdateAsync(
             integration.OrganizationId != organizationId ||
             integration.Type != updatedIntegration.Type)
         {
-            throw new NotFoundException();
+            throw new BadRequestException("Integration not found for this organization with the specified type.");
         }
 
         updatedIntegration.Id = integration.Id;
diff --git a/test/Api.Test/Dirt/Controllers/OrganizationIntegrationControllerTests.cs b/test/Api.Test/Dirt/Controllers/OrganizationIntegrationControllerTests.cs
@@ -5,7 +5,6 @@
 using Bit.Core.Dirt.Entities;
 using Bit.Core.Dirt.Enums;
 using Bit.Core.Dirt.EventIntegrations.OrganizationIntegrations.Interfaces;
-using Bit.Core.Exceptions;
 using Bit.Test.Common.AutoFixture;
 using Bit.Test.Common.AutoFixture.Attributes;
 using Microsoft.AspNetCore.Mvc;
@@ -34,7 +33,8 @@ public async Task GetAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
             .OrganizationOwner(organizationId)
             .Returns(false);
 
-        await Assert.ThrowsAsync<NotFoundException>(() => sutProvider.Sut.GetAsync(organizationId));
+        var result = await sutProvider.Sut.GetAsync(organizationId);
+        Assert.IsType<NotFoundResult>(result.Result);
     }
 
     [Theory, BitAutoData]
@@ -56,8 +56,11 @@ public async Task GetAsync_IntegrationsExist_ReturnsIntegrations(
         await sutProvider.GetDependency<IGetOrganizationIntegrationsQuery>().Received(1)
             .GetManyByOrganizationAsync(organizationId);
 
-        Assert.Equal(integrations.Count, result.Count);
-        Assert.All(result, r => Assert.IsType<OrganizationIntegrationResponseModel>(r));
+        Assert.IsType<OkObjectResult>(result.Result);
+        var okResult = result.Result as OkObjectResult;
+        var returnedIntegrations = okResult.Value as List<OrganizationIntegrationResponseModel>;
+        Assert.Equal(integrations.Count, returnedIntegrations.Count);
+        Assert.All(returnedIntegrations, r => Assert.IsType<OrganizationIntegrationResponseModel>(r));
     }
 
     [Theory, BitAutoData]
@@ -71,11 +74,13 @@ public async Task GetAsync_NoIntegrations_ReturnsEmptyList(
             .Returns(true);
         sutProvider.GetDependency<IGetOrganizationIntegrationsQuery>()
             .GetManyByOrganizationAsync(organizationId)
-            .Returns([]);
+            .Returns(new List<OrganizationIntegration>());
 
         var result = await sutProvider.Sut.GetAsync(organizationId);
 
-        Assert.Empty(result);
+        var okResult = result.Result as OkObjectResult;
+        var returnedIntegrations = okResult.Value as List<OrganizationIntegrationResponseModel>;
+        Assert.Empty(returnedIntegrations);
     }
 
     [Theory, BitAutoData]
@@ -129,7 +134,7 @@ public async Task CreateAsync_TheTypeAlreadyExists_ThrowsConflict(
     }
 
     [Theory, BitAutoData]
-    public async Task CreateAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
+    public async Task CreateAsync_UserIsNotOrganizationAdmin_ReturnsNotFound(
         SutProvider<OrganizationIntegrationController> sutProvider,
         Guid organizationId)
     {
@@ -138,8 +143,9 @@ public async Task CreateAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
             .OrganizationOwner(organizationId)
             .Returns(false);
 
-        await Assert.ThrowsAsync<NotFoundException>(async () =>
-            await sutProvider.Sut.CreateAsync(organizationId, _webhookRequestModel));
+        var response = await sutProvider.Sut.CreateAsync(organizationId, _webhookRequestModel);
+
+        Assert.IsType<NotFoundResult>(response.Result);
     }
 
     [Theory, BitAutoData]
@@ -178,7 +184,7 @@ await sutProvider.GetDependency<IDeleteOrganizationIntegrationCommand>().Receive
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
+    public async Task DeleteAsync_UserIsNotOrganizationAdmin_ReturnsNotFound(
         SutProvider<OrganizationIntegrationController> sutProvider,
         Guid organizationId,
         Guid integrationId)
@@ -188,8 +194,9 @@ public async Task DeleteAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
             .OrganizationOwner(organizationId)
             .Returns(false);
 
-        await Assert.ThrowsAsync<NotFoundException>(async () =>
-            await sutProvider.Sut.DeleteAsync(organizationId, integrationId));
+        var response = await sutProvider.Sut.DeleteAsync(organizationId, integrationId);
+
+        Assert.IsType<NotFoundResult>(response);
     }
 
     [Theory, BitAutoData]
@@ -217,12 +224,16 @@ await sutProvider.GetDependency<IUpdateOrganizationIntegrationCommand>().Receive
             .UpdateAsync(organizationId, integrationId, Arg.Is<OrganizationIntegration>(i =>
                 i.OrganizationId == organizationId &&
                 i.Type == IntegrationType.Webhook));
-        Assert.IsType<OrganizationIntegrationResponseModel>(response);
-        Assert.Equal(IntegrationType.Webhook, response.Type);
+        Assert.IsType<OkObjectResult>(response.Result);
+        var okResult = response.Result as OkObjectResult;
+        Assert.NotNull(okResult);
+        var resultValue = okResult!.Value as OrganizationIntegrationResponseModel;
+        Assert.NotNull(resultValue);
+        Assert.Equal(IntegrationType.Webhook, resultValue!.Type);
     }
 
     [Theory, BitAutoData]
-    public async Task UpdateAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
+    public async Task UpdateAsync_UserIsNotOrganizationAdmin_ReturnsNotFound(
         SutProvider<OrganizationIntegrationController> sutProvider,
         Guid organizationId,
         Guid integrationId)
@@ -232,7 +243,8 @@ public async Task UpdateAsync_UserIsNotOrganizationAdmin_ThrowsNotFound(
             .OrganizationOwner(organizationId)
             .Returns(false);
 
-        await Assert.ThrowsAsync<NotFoundException>(async () =>
-            await sutProvider.Sut.UpdateAsync(organizationId, integrationId, _webhookRequestModel));
+        var response = await sutProvider.Sut.UpdateAsync(organizationId, integrationId, _webhookRequestModel);
+
+        Assert.IsType<NotFoundResult>(response.Result);
     }
 }
diff --git a/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/CreateOrganizationIntegrationConfigurationCommandTests.cs b/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/CreateOrganizationIntegrationConfigurationCommandTests.cs
@@ -99,7 +99,7 @@ await sutProvider.GetDependency<IFusionCache>().DidNotReceive()
     }
 
     [Theory, BitAutoData]
-    public async Task CreateAsync_IntegrationDoesNotExist_ThrowsNotFound(
+    public async Task CreateAsync_IntegrationDoesNotExist_ThrowsBadRequest(
         SutProvider<CreateOrganizationIntegrationConfigurationCommand> sutProvider,
         Guid organizationId,
         Guid integrationId,
@@ -109,7 +109,7 @@ public async Task CreateAsync_IntegrationDoesNotExist_ThrowsNotFound(
             .GetByIdAsync(integrationId)
             .Returns((OrganizationIntegration)null);
 
-        await Assert.ThrowsAsync<NotFoundException>(
+        await Assert.ThrowsAsync<BadRequestException>(
             () => sutProvider.Sut.CreateAsync(organizationId, integrationId, configuration));
 
         await sutProvider.GetDependency<IOrganizationIntegrationConfigurationRepository>().DidNotReceive()
@@ -121,7 +121,7 @@ await sutProvider.GetDependency<IFusionCache>().DidNotReceive()
     }
 
     [Theory, BitAutoData]
-    public async Task CreateAsync_IntegrationDoesNotBelongToOrganization_ThrowsNotFound(
+    public async Task CreateAsync_IntegrationDoesNotBelongToOrganization_ThrowsBadRequest(
         SutProvider<CreateOrganizationIntegrationConfigurationCommand> sutProvider,
         Guid organizationId,
         Guid integrationId,
@@ -135,7 +135,7 @@ public async Task CreateAsync_IntegrationDoesNotBelongToOrganization_ThrowsNotFo
             .GetByIdAsync(integrationId)
             .Returns(integration);
 
-        await Assert.ThrowsAsync<NotFoundException>(
+        await Assert.ThrowsAsync<BadRequestException>(
             () => sutProvider.Sut.CreateAsync(organizationId, integrationId, configuration));
 
         await sutProvider.GetDependency<IOrganizationIntegrationConfigurationRepository>().DidNotReceive()
diff --git a/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/DeleteOrganizationIntegrationConfigurationCommandTests.cs b/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/DeleteOrganizationIntegrationConfigurationCommandTests.cs
diff --git a/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/UpdateOrganizationIntegrationConfigurationCommandTests.cs b/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrationConfigurations/UpdateOrganizationIntegrationConfigurationCommandTests.cs
diff --git a/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrations/DeleteOrganizationIntegrationCommandTests.cs b/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrations/DeleteOrganizationIntegrationCommandTests.cs
diff --git a/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrations/UpdateOrganizationIntegrationCommandTests.cs b/test/Core.Test/Dirt/EventIntegrations/OrganizationIntegrations/UpdateOrganizationIntegrationCommandTests.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`using Bit.Api.Dirt.Models.Response;`
`3`	`3`	`using Bit.Core.Context;`
`4`	`4`	`using Bit.Core.Dirt.EventIntegrations.OrganizationIntegrations.Interfaces;`
`5`		`-using Bit.Core.Exceptions;`
`6`	`5`	`using Microsoft.AspNetCore.Authorization;`
`7`	`6`	`using Microsoft.AspNetCore.Mvc;`
`8`	`7`
`@@ -18,17 +17,17 @@ public class OrganizationIntegrationController(`
`18`	`17`	`IGetOrganizationIntegrationsQuery getQuery) : Controller`
`19`	`18`	`{`
`20`	`19`	`[HttpGet("")]`
`21`		`- public async Task<List<OrganizationIntegrationResponseModel>> GetAsync(Guid organizationId)`
	`20`	`+ public async Task<ActionResult<List<OrganizationIntegrationResponseModel>>> GetAsync(Guid organizationId)`
`22`	`21`	`{`
`23`	`22`	`if (!await HasPermission(organizationId))`
`24`	`23`	`{`
`25`		`- throw new NotFoundException();`
	`24`	`+ return NotFound();`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`var integrations = await getQuery.GetManyByOrganizationAsync(organizationId);`
`29`		`- return integrations`
	`28`	`+ return Ok(integrations`
`30`	`29`	`.Select(integration => new OrganizationIntegrationResponseModel(integration))`
`31`		`- .ToList();`
	`30`	`+ .ToList());`
`32`	`31`	`}`
`33`	`32`
`34`	`33`	`/// <summary>`
`@@ -38,7 +37,7 @@ public async Task<List<OrganizationIntegrationResponseModel>> GetAsync(Guid orga`
`38`	`37`	`/// <param name="organizationId"></param>`
`39`	`38`	`/// <param name="model"></param>`
`40`	`39`	`/// <returns></returns>`
`41`		`- /// <exception cref="NotFoundException">Not enough permissions to access the organization.</exception>`
	`40`	`+ /// <exception cref="NotFoundResult">Not enough permissions to access the organization.</exception>`
`42`	`41`	`/// <exception cref="ConflictResult">When an integration of the same type already exists for the organization.</exception>`
`43`	`42`	`[HttpPost("")]`
`44`	`43`	`public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsync(Guid organizationId, [FromBody] OrganizationIntegrationRequestModel model)`
`@@ -50,7 +49,7 @@ public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsyn`
`50`	`49`
`51`	`50`	`if (!await HasPermission(organizationId))`
`52`	`51`	`{`
`53`		`- throw new NotFoundException();`
	`52`	`+ return NotFound();`
`54`	`53`	`}`
`55`	`54`
`56`	`55`	`var integration = model.ToOrganizationIntegration(organizationId);`
`@@ -62,40 +61,40 @@ public async Task<ActionResult<OrganizationIntegrationResponseModel>> CreateAsyn`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`var created = await createCommand.CreateAsync(integration);`
`65`		`-`
`66`	`64`	`return Ok(new OrganizationIntegrationResponseModel(created));`
	`65`	`+`
`67`	`66`	`}`
`68`	`67`
`69`	`68`	`[HttpPut("{integrationId:guid}")]`
`70`		`- public async Task<OrganizationIntegrationResponseModel> UpdateAsync(Guid organizationId, Guid integrationId, [FromBody] OrganizationIntegrationRequestModel model)`
	`69`	`+ public async Task<ActionResult<OrganizationIntegrationResponseModel>> UpdateAsync(Guid organizationId, Guid integrationId, [FromBody] OrganizationIntegrationRequestModel model)`
`71`	`70`	`{`
`72`	`71`	`if (!await HasPermission(organizationId))`
`73`	`72`	`{`
`74`		`- throw new NotFoundException();`
	`73`	`+ return NotFound();`
`75`	`74`	`}`
`76`	`75`
`77`	`76`	`var integration = model.ToOrganizationIntegration(organizationId);`
`78`	`77`	`var updated = await updateCommand.UpdateAsync(organizationId, integrationId, integration);`
`79`		`-`
`80`		`- return new OrganizationIntegrationResponseModel(updated);`
	`78`	`+ return Ok(new OrganizationIntegrationResponseModel(updated));`
`81`	`79`	`}`
`82`	`80`
`83`	`81`	`[HttpDelete("{integrationId:guid}")]`
`84`		`- public async Task DeleteAsync(Guid organizationId, Guid integrationId)`
	`82`	`+ public async Task<IActionResult> DeleteAsync(Guid organizationId, Guid integrationId)`
`85`	`83`	`{`
`86`	`84`	`if (!await HasPermission(organizationId))`
`87`	`85`	`{`
`88`		`- throw new NotFoundException();`
	`86`	`+ return NotFound();`
`89`	`87`	`}`
`90`	`88`
`91`	`89`	`await deleteCommand.DeleteAsync(organizationId, integrationId);`
	`90`	`+ return NoContent();`
`92`	`91`	`}`
`93`	`92`
`94`	`93`	`[HttpPost("{integrationId:guid}/delete")]`
`95`	`94`	`[Obsolete("This endpoint is deprecated. Use DELETE method instead")]`
`96`		`- public async Task PostDeleteAsync(Guid organizationId, Guid integrationId)`
	`95`	`+ public async Task<IActionResult> PostDeleteAsync(Guid organizationId, Guid integrationId)`
`97`	`96`	`{`
`98`		`- await DeleteAsync(organizationId, integrationId);`
	`97`	`+ return await DeleteAsync(organizationId, integrationId);`
`99`	`98`	`}`
`100`	`99`
`101`	`100`	`private async Task<bool> HasPermission(Guid organizationId)`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public async Task<OrganizationIntegrationConfiguration> CreateAsync(`
`27`	`27`	`var integration = await integrationRepository.GetByIdAsync(integrationId);`
`28`	`28`	`if (integration == null \|\| integration.OrganizationId != organizationId)`
`29`	`29`	`{`
`30`		`- throw new NotFoundException();`
	`30`	`+ throw new BadRequestException();`
`31`	`31`	`}`
`32`	`32`	`if (!validator.ValidateConfiguration(integration.Type, configuration))`
`33`	`33`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,12 @@ public async Task DeleteAsync(Guid organizationId, Guid integrationId, Guid conf`
`21`	`21`	`var integration = await integrationRepository.GetByIdAsync(integrationId);`
`22`	`22`	`if (integration == null \|\| integration.OrganizationId != organizationId)`
`23`	`23`	`{`
`24`		`- throw new NotFoundException();`
	`24`	`+ throw new BadRequestException("Integration not found for this organization.");`
`25`	`25`	`}`
`26`	`26`	`var configuration = await configurationRepository.GetByIdAsync(configurationId);`
`27`	`27`	`if (configuration is null \|\| configuration.OrganizationIntegrationId != integrationId)`
`28`	`28`	`{`
`29`		`- throw new NotFoundException();`
	`29`	`+ throw new BadRequestException("Configuration not found for this integration.");`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`await configurationRepository.DeleteAsync(configuration);`
Original file line number	Diff line number	Diff line change
`@@ -28,12 +28,12 @@ public async Task<OrganizationIntegrationConfiguration> UpdateAsync(`
`28`	`28`	`var integration = await integrationRepository.GetByIdAsync(integrationId);`
`29`	`29`	`if (integration == null \|\| integration.OrganizationId != organizationId)`
`30`	`30`	`{`
`31`		`- throw new NotFoundException();`
	`31`	`+ throw new BadRequestException("Integration not found for this organization.");`
`32`	`32`	`}`
`33`	`33`	`var configuration = await configurationRepository.GetByIdAsync(configurationId);`
`34`	`34`	`if (configuration is null \|\| configuration.OrganizationIntegrationId != integrationId)`
`35`	`35`	`{`
`36`		`- throw new NotFoundException();`
	`36`	`+ throw new BadRequestException("Configuration not found for this integration.");`
`37`	`37`	`}`
`38`	`38`	`if (!validator.ValidateConfiguration(integration.Type, updatedConfiguration))`
`39`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public async Task DeleteAsync(Guid organizationId, Guid integrationId)`
`20`	`20`	`var integration = await integrationRepository.GetByIdAsync(integrationId);`
`21`	`21`	`if (integration is null \|\| integration.OrganizationId != organizationId)`
`22`	`22`	`{`
`23`		`- throw new NotFoundException();`
	`23`	`+ throw new BadRequestException("Integration not found for this organization.");`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`await integrationRepository.DeleteAsync(integration);`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public interface IDeleteOrganizationIntegrationCommand`
`10`	`10`	`/// </summary>`
`11`	`11`	`/// <param name="organizationId">The unique identifier of the organization.</param>`
`12`	`12`	`/// <param name="integrationId">The unique identifier of the integration to delete.</param>`
`13`		`- /// <exception cref="Exceptions.NotFoundException">Thrown when the integration does not exist`
	`13`	`+ /// <exception cref="Exceptions.BadRequestException">Thrown when the integration does not exist`
`14`	`14`	`/// or does not belong to the specified organization.</exception>`
`15`	`15`	`Task DeleteAsync(Guid organizationId, Guid integrationId);`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public interface IUpdateOrganizationIntegrationCommand`
`14`	`14`	`/// <param name="integrationId">The unique identifier of the integration to update.</param>`
`15`	`15`	`/// <param name="updatedIntegration">The updated organization integration data.</param>`
`16`	`16`	`/// <returns>The updated organization integration.</returns>`
`17`		`- /// <exception cref="Exceptions.NotFoundException">Thrown when the integration does not exist,`
	`17`	`+ /// <exception cref="Exceptions.BadRequestException">Thrown when the integration does not exist,`
`18`	`18`	`/// does not belong to the specified organization, or the integration type does not match.</exception>`
`19`	`19`	`Task<OrganizationIntegration> UpdateAsync(Guid organizationId, Guid integrationId, OrganizationIntegration updatedIntegration);`
`20`	`20`	`}`