#328 Implementation of API logic for placing a SMS notifications order

src/Altinn.Notifications.Core/Models/Address/IAddressPoint.cs

@@ -8,6 +8,7 @@ namespace Altinn.Notifications.Core.Models.Address;
 /// Interface describing an address point
 /// </summary>
 [JsonDerivedType(typeof(EmailAddressPoint), "email")]
+[JsonDerivedType(typeof(SmsAddressPoint), "sms")]
 [JsonPolymorphic(TypeDiscriminatorPropertyName = "$")]
 public interface IAddressPoint
 {

src/Altinn.Notifications/Altinn.Notifications.csproj

@@ -14,6 +14,7 @@
     <PackageReference Include="Altinn.Common.PEP" Version="1.3.0" />
     <PackageReference Include="FluentValidation" Version="11.9.0" />
     <PackageReference Include="JWTCookieAuthentication" Version="4.0.1" />
+    <PackageReference Include="libphonenumber-csharp" Version="8.13.28" />
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.22.0" />
     <PackageReference Include="Azure.Extensions.AspNetCore.Configuration.Secrets" Version="1.3.0" />
     <PackageReference Include="Azure.Identity" Version="1.10.4" />

src/Altinn.Notifications/Controllers/SmsNotificationOrdersController.cs

@@ -0,0 +1,85 @@
+using System.Collections;
+using Altinn.Notifications.Configuration;
+using Altinn.Notifications.Core.Models;
+using Altinn.Notifications.Core.Models.Orders;
+using Altinn.Notifications.Core.Services.Interfaces;
+using Altinn.Notifications.Extensions;
+using Altinn.Notifications.Mappers;
+using Altinn.Notifications.Models;
+using Altinn.Notifications.Validators;
+
+using FluentValidation;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+using Swashbuckle.AspNetCore.Annotations;
+using Swashbuckle.AspNetCore.Filters;
+
+namespace Altinn.Notifications.Controllers;
+
+/// <summary>
+/// Controller for all operations related to SMS notification orders
+/// </summary>
+[Route("notifications/api/v1/orders/sms")]
+[ApiController]
+[Authorize(Policy = AuthorizationConstants.POLICY_CREATE_SCOPE_OR_PLATFORM_ACCESS)]
+[SwaggerResponse(401, "Caller is unauthorized")]
+[SwaggerResponse(403, "Caller is not authorized to access the requested resource")]
+
+public class SmsNotificationOrdersController : ControllerBase
+{
+    private readonly IValidator<SmsNotificationOrderRequestExt> _validator;
+    private readonly IOrderRequestService _orderRequestService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SmsNotificationOrdersController"/> class.
+    /// </summary>
+    public SmsNotificationOrdersController(IValidator<SmsNotificationOrderRequestExt> validator, IOrderRequestService orderRequestService)
+    {
+        _validator = validator;
+        _orderRequestService = orderRequestService;
+    }
+
+    /// <summary>
+    /// Add an SMS notification order.
+    /// </summary>
+    /// <remarks>
+    /// The API will accept the request after som basic validation of the request.
+    /// The system will also attempt to verify that it will be possible to fulfill the order.
+    /// </remarks>
+    /// <returns>The id of the registered notification order</returns>
+    [HttpPost]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [SwaggerResponse(202, "The notification order was accepted", typeof(OrderIdExt))]
+    [SwaggerResponse(400, "The notification order is invalid", typeof(ValidationProblemDetails))]
+    [SwaggerResponseHeader(202, "Location", "string", "Link to access the newly created notification order.")]
+    public async Task<ActionResult<OrderIdExt>> Post(SmsNotificationOrderRequestExt smsNotificationOrderRequest)
+    {
+        FluentValidation.Results.ValidationResult validationResult = _validator.Validate(smsNotificationOrderRequest);
+        if (!validationResult.IsValid)
+        {
+            validationResult.AddToModelState(this.ModelState);
+            return ValidationProblem(ModelState);
+        }
+
+        string? creator = HttpContext.GetOrg();
+
+        if (creator == null)
+        {
+            return Forbid();
+        }
+
+        NotificationOrderRequest orderRequest = smsNotificationOrderRequest.MapToOrderRequest(creator);
+        (NotificationOrder? registeredOrder, ServiceError? error) = await _orderRequestService.RegisterNotificationOrder(orderRequest);
+
+        if (error != null)
+        {
+            return StatusCode(error.ErrorCode, error.ErrorMessage);
+        }
+
+        string selfLink = registeredOrder!.GetSelfLink();
+        return Accepted(selfLink, new OrderIdExt(registeredOrder!.Id));
+    }
+}

src/Altinn.Notifications/Mappers/OrderMapper.cs

@@ -34,6 +34,27 @@ public static NotificationOrderRequest MapToOrderRequest(this EmailNotificationO
             recipients);
     }
 
+    /// <summary>
+    /// Maps a <see cref="SmsNotificationOrderRequestExt"/> to a <see cref="NotificationOrderRequest"/>
+    /// </summary>
+    public static NotificationOrderRequest MapToOrderRequest(this SmsNotificationOrderRequestExt extRequest, string creator)
+    {
+        INotificationTemplate smsTemplate = new SmsTemplate(extRequest.SenderNumber, extRequest.Body);
+
+        List<Recipient> recipients = new();
+
+        recipients.AddRange(
+            extRequest.Recipients.Select(r => new Recipient(string.Empty, new List<IAddressPoint>() { new SmsAddressPoint(r.MobileNumber!) })));
+
+        return new NotificationOrderRequest(
+            extRequest.SendersReference,
+            creator,
+            new List<INotificationTemplate>() { smsTemplate },
+            extRequest.RequestedSendTime.ToUniversalTime(),
+            NotificationChannel.Sms,
+            recipients);
+    }
+
     /// <summary>
     /// Maps a <see cref="NotificationOrder"/> to a <see cref="NotificationOrderExt"/>
     /// </summary>
@@ -138,7 +159,8 @@ internal static List<RecipientExt> MapToRecipientExt(this List<Recipient> recipi
         recipientExt.AddRange(
             recipients.Select(r => new RecipientExt
             {
-                EmailAddress = GetEmailFromAddressList(r.AddressInfo)
+                EmailAddress = GetEmailFromAddressList(r.AddressInfo),
+                MobileNumber = GetMobileNumberFromAddressList(r.AddressInfo) 
             }));
 
         return recipientExt;
@@ -164,4 +186,13 @@ private static IBaseNotificationOrderExt MapBaseNotificationOrder(this IBaseNoti
 
         return emailAddressPoint?.EmailAddress;
     }
+
+    private static string? GetMobileNumberFromAddressList(List<IAddressPoint> addressPoints)
+    {
+        var smsAddressPoint = addressPoints
+            .Find(a => a.AddressType.Equals(AddressType.Sms))
+            as SmsAddressPoint;
+
+        return smsAddressPoint?.MobileNumber;
+    }
 }

src/Altinn.Notifications/Models/EmailNotificationOrderRequestExt.cs

@@ -7,7 +7,7 @@ namespace Altinn.Notifications.Models;
 /// Class representing an email notiication order request
 /// </summary>
 /// <remarks>
-/// External representaion to be used in the API.
+/// External representation to be used in the API.
 /// </remarks>
 public class EmailNotificationOrderRequestExt
 {

src/Altinn.Notifications/Models/RecipientExt.cs

@@ -15,4 +15,10 @@ public class RecipientExt
     /// </summary>
     [JsonPropertyName("emailAddress")]
     public string? EmailAddress { get; set; }
+
+    /// <summary>
+    /// Gets or sets the mobile number of the recipient
+    /// </summary>
+    [JsonPropertyName("mobileNumber")]
+    public string? MobileNumber { get; set; }
 }

src/Altinn.Notifications/Models/SmsNotificationOrderRequestExt.cs

@@ -0,0 +1,51 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Altinn.Notifications.Models;
+
+/// <summary>
+/// Class representing an SMS notiication order request
+/// </summary>
+/// <remarks>
+/// External representation to be used in the API.
+/// </remarks>
+public class SmsNotificationOrderRequestExt
+{
+    /// <summary>
+    /// Gets or sets the sender number of the SMS 
+    /// </summary>
+    [JsonPropertyName("senderNumber")]
+    public string SenderNumber { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the body of the SMS
+    /// </summary>
+    [JsonPropertyName("body")]
+    public string Body { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the send time of the SMS. Defaults to UtcNow.
+    /// </summary>
+    [JsonPropertyName("requestedSendTime")]
+    public DateTime RequestedSendTime { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Gets or sets the senders reference on the notification
+    /// </summary>
+    [JsonPropertyName("sendersReference")]
+    public string? SendersReference { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of recipients
+    /// </summary>
+    [JsonPropertyName("recipients")]
+    public List<RecipientExt> Recipients { get; set; } = new List<RecipientExt>();
+
+    /// <summary>
+    /// Json serialized the <see cref="SmsNotificationOrderRequestExt"/>
+    /// </summary>
+    public string Serialize()
+    {
+        return JsonSerializer.Serialize(this);
+    }
+}

src/Altinn.Notifications/Program.cs

@@ -1,4 +1,4 @@
 #nullable disable
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -140,7 +140,7 @@
     services.AddSingleton(config);
     if (!string.IsNullOrEmpty(applicationInsightsConnectionString))
     {
         services.AddSingleton(typeof(ITelemetryChannel), new ServerTelemetryChannel() { StorageFolder = "/tmp/logtelemetry" });
 
         services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
         {
@@ -247,6 +247,7 @@
 {
     ValidatorOptions.Global.LanguageManager.Enabled = false;
     services.AddSingleton<IValidator<EmailNotificationOrderRequestExt>, EmailNotificationOrderRequestValidator>();
+    services.AddSingleton<IValidator<SmsNotificationOrderRequestExt>, SmsNotificationOrderRequestValidator>();
 }
 
 void IncludeXmlComments(SwaggerGenOptions swaggerGenOptions)

src/Altinn.Notifications/Validators/SmsNotificationOrderRequestValidator.cs

@@ -0,0 +1,56 @@
+using System.Text.RegularExpressions;
+
+using Altinn.Notifications.Models;
+
+using FluentValidation;
+using PhoneNumbers;
+
+namespace Altinn.Notifications.Validators;
+
+/// <summary>
+/// Class containing validation logic for the <see cref="SmsNotificationOrderRequestExt"/> model
+/// </summary>
+public class SmsNotificationOrderRequestValidator : AbstractValidator<SmsNotificationOrderRequestExt>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SmsNotificationOrderRequestValidator"/> class.
+    /// </summary>
+    public SmsNotificationOrderRequestValidator()
+    {
+        RuleFor(order => order.Recipients)
+            .NotEmpty()
+            .WithMessage("One or more recipient is required.")
+            .Must(recipients => recipients.TrueForAll(a => IsValidMobileNumber(a.MobileNumber)))
+            .WithMessage("A valid mobile number starting with country code must be provided for all recipients.");
+
+        RuleFor(order => order.RequestedSendTime)
+            .Must(sendTime => sendTime.Kind != DateTimeKind.Unspecified)
+            .WithMessage("The requested send time value must have specified a time zone.")
+            .Must(sendTime => sendTime >= DateTime.UtcNow.AddMinutes(-5))
+            .WithMessage("Send time must be in the future. Leave blank to send immediately.");
+
+        RuleFor(order => order.Body).NotEmpty();
+    }
+
+    /// <summary>
+    /// Validated as mobile number based on the Altinn 2 regex
+    /// </summary>
+    /// <param name="mobileNumber">The string to validate as an mobile number</param>
+    /// <returns>A boolean indicating that the mobile number is valid or not</returns>
+    internal static bool IsValidMobileNumber(string? mobileNumber)
+    {
+        if (string.IsNullOrEmpty(mobileNumber) || (!mobileNumber.StartsWith('+') && !mobileNumber.StartsWith("00")))
+        {
+            return false;
+        }
+
+        if (mobileNumber.StartsWith("00"))
+        {
+            mobileNumber = "+" + mobileNumber.Remove(0, 2);
+        }
+
+        PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.GetInstance();
+        PhoneNumber phoneNumber = phoneNumberUtil.Parse(mobileNumber, null);
+        return phoneNumberUtil.IsValidNumber(phoneNumber);
+    }
+}