new endpoint for unit contact points (#151)

* new endpoint for unit contact points

* added UnitProfileClientTest

* test implemented, but not working

* fixed unit test for unitclient

* fixed code smell

* still fixing code smells

* fixed final code smell

* Update src/Altinn.Profile.Integrations/SblBridge/UnitProfileClient.cs

* Fixed pr comments

src/Altinn.Profile.Core/Integrations/IUnitProfileClient.cs

@@ -0,0 +1,17 @@
+using Altinn.Profile.Core.Unit.ContactPoints;
+
+namespace Altinn.Profile.Core.Integrations
+{
+    /// <summary>
+    /// Interface describing a client for the user profile service
+    /// </summary>
+    public interface IUnitProfileClient
+    {
+        /// <summary>
+        /// Provides a list of user registered contact points based on the lookup criteria
+        /// </summary>
+        /// <param name="lookup">Lookup object containing a list of organizations and a resource</param>
+        /// <returns>A list of unit contact points</returns>
+        Task<Result<UnitContactPointsList, bool>> GetUserRegisteredContactPoints(UnitContactPointLookup lookup);
+    }
+}

src/Altinn.Profile.Core/ServiceCollectionExtensions.cs

@@ -1,4 +1,5 @@
 using Altinn.Profile.Core;
+using Altinn.Profile.Core.Unit.ContactPoints;
 using Altinn.Profile.Core.User;
 using Altinn.Profile.Core.User.ContactPoints;
 
@@ -24,6 +25,7 @@ public static void AddCoreServices(this IServiceCollection services, IConfigurat
             .AddMemoryCache()
             .AddSingleton<IUserProfileService, UserProfileService>()
             .AddSingleton<IUserContactPoints, UserContactPointService>()
-            .Decorate<IUserProfileService, UserProfileCachingDecorator>();
+            .Decorate<IUserProfileService, UserProfileCachingDecorator>()
+            .AddSingleton<IUnitContactPoints, UnitContactPointService>();
     }
 }

src/Altinn.Profile.Core/Unit.ContactPoints/IUnitContactPoints.cs

@@ -0,0 +1,16 @@
+using Altinn.Profile.Core.Unit.ContactPoints;
+
+namespace Altinn.Profile.Core.User.ContactPoints;
+
+/// <summary>
+/// Class describing the methods required for user contact point service
+/// </summary>
+public interface IUnitContactPoints
+{
+    /// <summary>
+    /// Method for retriveing user registered contact points for a unit
+    /// </summary>
+    /// <param name="lookup">A lookup object containing a list of organisation numbers and the resource to lookup contact points for</param>
+    /// <returns>The users' contact points and reservation status or a boolean if failure.</returns>
+    Task<Result<UnitContactPointsList, bool>> GetUserRegisteredContactPoints(UnitContactPointLookup lookup);
+}

src/Altinn.Profile.Core/Unit.ContactPoints/UnitContactPointLookup.cs

@@ -0,0 +1,18 @@
+namespace Altinn.Profile.Core.Unit.ContactPoints
+{
+    /// <summary>
+    /// A class describing the query model for contact points for units
+    /// </summary>
+    public class UnitContactPointLookup
+    {
+        /// <summary>
+        /// Gets or sets the list of organisation numbers to lookup contact points for
+        /// </summary>
+        public List<string> OrganizationNumbers { get; set; } = [];
+
+        /// <summary>
+        /// Gets or sets the resource id to filter the contact points by
+        /// </summary>
+        public string ResourceId { get; set; } = string.Empty;
+    }
+}

src/Altinn.Profile.Core/Unit.ContactPoints/UnitContactPointService.cs

@@ -0,0 +1,28 @@
+using Altinn.Profile.Core.Integrations;
+using Altinn.Profile.Core.User.ContactPoints;
+
+namespace Altinn.Profile.Core.Unit.ContactPoints
+{
+    /// <summary>
+    /// Implementation of the <see cref="IUnitContactPoints"/> interface using a REST client to retrieve profile data "/>
+    /// </summary>
+    public class UnitContactPointService : IUnitContactPoints
+    {
+        private readonly IUnitProfileClient _unitClient;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnitContactPointService"/> class.
+        /// </summary>
+        public UnitContactPointService(IUnitProfileClient unitClient)
+        {
+            _unitClient = unitClient;
+        }
+
+        /// <inheritdoc/>
+        public async Task<Result<UnitContactPointsList, bool>> GetUserRegisteredContactPoints(UnitContactPointLookup lookup)
+        {
+            Result<UnitContactPointsList, bool> result = await _unitClient.GetUserRegisteredContactPoints(lookup);
+            return result;
+        }
+    }
+}

src/Altinn.Profile.Core/Unit.ContactPoints/UnitContactPoints.cs

@@ -0,0 +1,36 @@
+using Altinn.Profile.Core.User.ContactPoints;
+
+namespace Altinn.Profile.Core.Unit.ContactPoints
+{
+    /// <summary>
+    /// Class describing the user registered contact points for a unit
+    /// </summary>
+    public class UnitContactPoints
+    {
+        /// <summary>
+        /// Gets or sets the organization number of the organization.
+        /// </summary>
+        public string OrganizationNumber { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the party id of the organization.
+        /// </summary>
+        public int PartyId { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of multiple contanct points associated with the organisation.
+        /// </summary>
+        public List<UserContactPoints> UserContactPoints { get; set; } = [];
+    }
+
+    /// <summary>
+    /// A list representation of <see cref="UnitContactPoints"/>
+    /// </summary>
+    public class UnitContactPointsList
+    {
+        /// <summary>
+        /// A list containing contact points for users
+        /// </summary>
+        public List<UnitContactPoints> ContactPointsList { get; set; } = [];
+    }
+}

src/Altinn.Profile.Core/User.ContactPoints/UserContactPoints.cs

@@ -1,7 +1,7 @@
 namespace Altinn.Profile.Core.User.ContactPoints;
 
 /// <summary>
-/// Class describing the availability of contact points for a user
+/// Class describing the contact points for a user
 /// </summary>
 public class UserContactPoints
 {

src/Altinn.Profile.Integrations/SblBridge/PartyNotificationContactPoints.cs

@@ -0,0 +1,75 @@
+using Altinn.Profile.Core.Unit.ContactPoints;
+using Altinn.Profile.Core.User.ContactPoints;
+
+namespace Altinn.Profile.Integrations.SblBridge
+{
+    /// <summary>
+    /// Model describing a container for a list of contact points.
+    /// </summary>
+    public class PartyNotificationContactPoints
+    {
+        /// <summary>
+        /// Gets or sets the party id of the organisation.
+        /// </summary>
+        public Guid? PartyId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the legacy id of the organisation.
+        /// </summary>
+        public int LegacyPartyId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the organization number of the organisation.
+        /// </summary>
+        public string OrganizationNumber { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets a list of multiple contanct points associated with the organisation.
+        /// </summary>
+        public List<UserRegisteredContactPoint> ContactPoints { get; set; } = new List<UserRegisteredContactPoint>();
+
+        /// <summary>
+        /// Maps a list of <see cref="PartyNotificationContactPoints"/> to a list of <see cref="UnitContactPoints"/>.
+        /// </summary>
+        public static UnitContactPointsList MapToUnitContactPoints(List<PartyNotificationContactPoints> source)
+        {
+            List<UnitContactPoints> contactPoints = source.Select(partyNotificationEndpoint => new UnitContactPoints
+            {
+                OrganizationNumber = partyNotificationEndpoint.OrganizationNumber,
+                PartyId = partyNotificationEndpoint.LegacyPartyId,
+                UserContactPoints = partyNotificationEndpoint.ContactPoints.Select(contactPoint => new UserContactPoints
+                {
+                    UserId = contactPoint.LegacyUserId,
+                    Email = contactPoint.Email,
+                    MobileNumber = contactPoint.MobileNumber
+                }).ToList()
+            }).ToList();
+
+            return new UnitContactPointsList() { ContactPointsList = contactPoints };
+        }
+    }
+
+    /// <summary>
+    /// Model describing the contact information that a user has associated with a party they can represent.
+    /// </summary>
+    public class UserRegisteredContactPoint
+    {
+        /// <summary>
+        /// Gets or sets the legacy user id for the owner of this party notification endpoint.
+        /// </summary>
+        /// <remarks>
+        /// This was named as legacy for consistency. Property for UUID will probably never be added.
+        /// </remarks>
+        public int LegacyUserId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the email address for this contact point.
+        /// </summary>
+        public string Email { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the mobile number for this contact point.
+        /// </summary>
+        public string MobileNumber { get; set; } = string.Empty;
+    }
+}

src/Altinn.Profile.Integrations/SblBridge/UnitProfileClient.cs

@@ -0,0 +1,70 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using Altinn.Profile.Core;
+using Altinn.Profile.Core.Integrations;
+using Altinn.Profile.Core.Unit.ContactPoints;
+
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Altinn.Profile.Integrations.SblBridge;
+
+/// <summary>
+/// Represents an implementation of <see cref="IUnitContactPointClient"/> using SBLBridge to obtain unit profile information.
+/// </summary>
+public class UnitProfileClient : IUnitProfileClient
+{
+    private readonly ILogger<UnitProfileClient> _logger;
+    private readonly HttpClient _client;
+    private readonly JsonSerializerOptions _serializerOptions;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UnitProfileClient"/> class
+    /// </summary>
+    /// <param name="httpClient">HttpClient from default http client factory</param>
+    /// <param name="logger">the logger</param>
+    /// <param name="settings">the sbl bridge settings</param>
+    public UnitProfileClient(
+        HttpClient httpClient,
+        ILogger<UnitProfileClient> logger,
+        IOptions<SblBridgeSettings> settings)
+    {
+        _logger = logger;
+        _client = httpClient;
+        _client.BaseAddress = new Uri(settings.Value.ApiProfileEndpoint);
+
+        _serializerOptions = new JsonSerializerOptions
+        {
+            WriteIndented = true,
+            PropertyNameCaseInsensitive = true,
+            Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) }
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<Result<UnitContactPointsList, bool>> GetUserRegisteredContactPoints(UnitContactPointLookup lookup)
+    {
+        string endpoint = $"units/contactpointslookup";
+
+        StringContent requestBody = new StringContent(JsonSerializer.Serialize(lookup), Encoding.UTF8, "application/json");
+
+        HttpResponseMessage response = await _client.PostAsync(endpoint, requestBody);
+
+        if (!response.IsSuccessStatusCode)
+        {
+            _logger.LogError(
+                "// UnitClient // GetUserRegisteredContactPoints // Unexpected response. Failed with {StatusCode} and message {Message}",
+                response.StatusCode,
+                await response.Content.ReadAsStringAsync());
+
+            return false;
+        }
+
+        string content = await response.Content.ReadAsStringAsync();
+        List<PartyNotificationContactPoints> partyNotificationEndpoints = JsonSerializer.Deserialize<List<PartyNotificationContactPoints>>(content, _serializerOptions)!;
+
+        return PartyNotificationContactPoints.MapToUnitContactPoints(partyNotificationEndpoints);
+    }
+}

src/Altinn.Profile.Integrations/ServiceCollectionExtensions.cs

@@ -22,8 +22,8 @@ public static void AddSblBridgeClients(this IServiceCollection services, IConfig
             .Get<SblBridgeSettings>()
             ?? throw new ArgumentNullException(nameof(config), "Required SblBridgeSettings is missing from application configuration");
 
-        services
-            .Configure<SblBridgeSettings>(config.GetSection(nameof(SblBridgeSettings)))
-            .AddHttpClient<IUserProfileClient, UserProfileClient>();
+        services.Configure<SblBridgeSettings>(config.GetSection(nameof(SblBridgeSettings)));
+        services.AddHttpClient<IUserProfileClient, UserProfileClient>();
+        services.AddHttpClient<IUnitProfileClient, UnitProfileClient>();
     }
 }

src/Altinn.Profile/Controllers/UnitContactPointController.cs

@@ -0,0 +1,45 @@
+using System.Threading.Tasks;
+
+using Altinn.Profile.Core;
+using Altinn.Profile.Core.Unit.ContactPoints;
+using Altinn.Profile.Core.User.ContactPoints;
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Altinn.Profile.Controllers
+{
+    /// <summary>
+    /// Controller for unit profile contact point API endpoints for internal consumption (e.g. Notifications) requiring neither authenticated user token nor access token authorization.
+    /// </summary>
+    [Route("profile/api/v1/units/contactpoint")]
+    [ApiExplorerSettings(IgnoreApi = true)]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    public class UnitContactPointController : ControllerBase
+    {
+        private readonly IUnitContactPoints _contactPointService;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnitContactPointController"/> class.
+        /// </summary>
+        public UnitContactPointController(IUnitContactPoints contactPointsService)
+        {
+            _contactPointService = contactPointsService;
+        }
+
+        /// <summary>
+        /// Endpoint looking up the contact points for the units provided in the lookup object in the request body
+        /// </summary>
+        /// <returns>Returns an overview of the user registered contact points for the provided units and given resource</returns>
+        [HttpPost("lookup")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<ActionResult<UnitContactPointsList>> PostLookup([FromBody] UnitContactPointLookup unitContactPointLookup)
+        {     
+            Result<UnitContactPointsList, bool> result = await _contactPointService.GetUserRegisteredContactPoints(unitContactPointLookup);
+            return result.Match<ActionResult<UnitContactPointsList>>(
+                         success => Ok(success),
+                         _ => Problem("Could not retrieve contact points"));
+        }
+    }
+}

src/Altinn.Profile/Controllers/UserContactPointController.cs

@@ -2,6 +2,7 @@
 
 using Altinn.Profile.Core;
 using Altinn.Profile.Core.User.ContactPoints;
+using Altinn.Profile.Models;
 
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;

src/Altinn.Profile.Core/User.ContactPoints/UserContactPointLookup.cs → src/Altinn.Profile/Models/UserContactPointLookup.cs

@@ -1,4 +1,6 @@
-namespace Altinn.Profile.Core.User.ContactPoints;
+using System.Collections.Generic;
+
+namespace Altinn.Profile.Models;
 
 /// <summary>
 /// A class respresenting a user contact point lookup object

src/Altinn.Profile/appsettings.json

@@ -4,7 +4,7 @@
     "JwtCookieName": "AltinnStudioRuntime"
   },
   "SblBridgeSettings": {
-    "ApiProfileEndpoint": "https://at22.altinn.cloud/sblbridge/profile/api/"
+    "ApiProfileEndpoint": "https://at24.altinn.cloud/sblbridge/profile/api/"
   },
   "CoreSettings": {
     "ProfileCacheLifetimeSeconds": 600