feat: upload static images to be used by the image component

backend/src/Designer/Controllers/ImageController.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Web;
+using Altinn.Studio.Designer.Enums;
+using Altinn.Studio.Designer.Exceptions.AppDevelopment;
+using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Altinn.Studio.Designer.TypedHttpClients.ImageClient;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Primitives;
+using Microsoft.Net.Http.Headers;
+
+namespace Altinn.Studio.Designer.Controllers;
+
+/// <summary>
+/// Controller containing actions related to images
+/// </summary>
+[Authorize]
+[AutoValidateAntiforgeryToken]
+[Route("designer/api/{org}/{app:regex(^(?!datamodels$)[[a-z]][[a-z0-9-]]{{1,28}}[[a-z0-9]]$)}/images")]
+public class ImageController : ControllerBase
+{
+
+    private readonly IImagesService _imagesService;
+    private readonly ImageClient _imageClient;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ImageController"/> class.
+    /// </summary>
+    /// <param name="imagesService">The images service.</param>
+    /// <param name="imageClient">A http client to validate external image url</param>
+    public ImageController(IImagesService imagesService, ImageClient imageClient)
+    {
+        _imagesService = imagesService;
+        _imageClient = imageClient;
+    }
+
+    /// <summary>
+    /// Endpoint for getting a specific image
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="app">Application identifier which is unique within an organisation.</param>
+    /// <param name="encodedImagePath">Relative encoded path of image to fetch</param>
+    /// <returns>Image</returns>
+    [HttpGet("{encodedImagePath}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public FileStreamResult GetImageByName(string org, string app, [FromRoute] string encodedImagePath)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+        string decodedImagePath = HttpUtility.UrlDecode(encodedImagePath);
+        var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+
+        return _imagesService.GetImage(editingContext, decodedImagePath);
+    }
+
+    /// <summary>
+    /// Endpoint for getting all image file names in application
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="app">Application identifier which is unique within an organisation.</param>
+    /// <returns>All image file names</returns>
+    [HttpGet("fileNames")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public ActionResult<List<string>> GetAllImagesFileNames(string org, string app)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+        var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+
+        List<string> imageFileNames = _imagesService.GetAllImageFileNames(editingContext);
+
+        return Ok(imageFileNames);
+    }
+
+    /// <summary>
+    /// Endpoint to validate a given url for fetching an external image.
+    /// </summary>
+    /// <param name="url">An external url to fetch an image to represent in the image component in the form.</param>
+    /// <returns>NotAnImage if url does not point at an image or NotValidUrl if url is invalid for any other reason</returns>
+    [HttpGet("validate")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<ImageUrlValidationResult> ValidateExternalImageUrl([FromQuery] string url)
+    {
+        return await _imageClient.ValidateUrlAsync(url);
+    }
+
+    /// <summary>
+    /// Endpoint for uploading image to application.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="app">Application identifier which is unique within an organisation.</param>
+    /// <param name="image">The actual image</param>
+    /// <param name="overrideExisting">Optional parameter that overrides existing image if set. Default is false</param>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult> UploadImage(string org, string app, [FromForm(Name = "file")] IFormFile image, [FromForm(Name = "overrideExisting")] bool overrideExisting = false)
+    {
+        if (image == null || image.Length == 0)
+        {
+            return BadRequest("No file uploaded.");
+        }
+        if (!IsValidImageContentType(image.ContentType))
+        {
+            throw new InvalidExtensionImageUploadException("The uploaded file is not a valid image.");
+        }
+
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        string imageName = GetFileNameFromUploadedFile(image);
+        try
+        {
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+            await _imagesService.UploadImage(editingContext, imageName, image.OpenReadStream(), overrideExisting);
+            return NoContent();
+        }
+        catch (InvalidOperationException e)
+        {
+            return BadRequest(e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Endpoint for deleting image from application.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="app">Application identifier which is unique within an organisation.</param>
+    /// <param name="encodedImagePath">Relative encoded path of image to delete</param>
+    [HttpDelete("{encodedImagePath}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<ActionResult> DeleteImage(string org, string app, [FromRoute] string encodedImagePath)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+        string decodedImagePath = HttpUtility.UrlDecode(encodedImagePath);
+        var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+
+        await _imagesService.DeleteImage(editingContext, decodedImagePath);
+
+        return NoContent();
+    }
+
+    private static string GetFileNameFromUploadedFile(IFormFile image)
+    {
+        return ContentDispositionHeaderValue.Parse(new StringSegment(image.ContentDisposition)).FileName.ToString();
+    }
+
+    private bool IsValidImageContentType(string contentType)
+    {
+        return contentType.ToLower().StartsWith("image/");
+    }
+
+}

backend/src/Designer/Controllers/PreviewController.cs

@@ -132,7 +132,7 @@ public FileStreamResult Image(string org, string app, string imageFilePath, Canc
 
             string developer = AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext);
             AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-            Stream imageStream = altinnAppGitRepository.GetImage(imageFilePath);
+            Stream imageStream = altinnAppGitRepository.GetImageAsStreamByFilePath(imageFilePath);
             return new FileStreamResult(imageStream, MimeTypeMap.GetMimeType(Path.GetExtension(imageFilePath).ToLower()));
         }
 

backend/src/Designer/Enums/ImageUrlValidationResult.cs

@@ -0,0 +1,18 @@
+using System.Runtime.Serialization;
+
+namespace Altinn.Studio.Designer.Enums;
+
+/// <summary>
+/// ImageUrlValidationResult
+/// </summary>
+public enum ImageUrlValidationResult
+{
+    [EnumMember(Value = "Ok")]
+    Ok,
+
+    [EnumMember(Value = "NotAnImage")]
+    NotAnImage,
+
+    [EnumMember(Value = "NotValidUrl")]
+    NotValidUrl
+}

backend/src/Designer/Exceptions/AppDevelopment/ConflictingFileNameException.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace Altinn.Studio.Designer.Exceptions.AppDevelopment;
+
+/// <summary>
+/// Indicates that a file was uploaded with the a conflicting file name
+/// </summary>
+[Serializable]
+public class ConflictingFileNameException : Exception
+{
+    /// <inheritdoc/>
+    public ConflictingFileNameException()
+    {
+    }
+
+    /// <inheritdoc/>
+    public ConflictingFileNameException(string message) : base(message)
+    {
+    }
+
+    /// <inheritdoc/>
+    public ConflictingFileNameException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

backend/src/Designer/Exceptions/AppDevelopment/InvalidExtensionImageUploadException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Altinn.Studio.Designer.Exceptions.AppDevelopment
+{
+    /// <summary>
+    /// Indicates that an image with invalid extension was uploaded
+    /// </summary>
+    [Serializable]
+    public class InvalidExtensionImageUploadException : Exception
+    {
+        /// <inheritdoc/>
+        public InvalidExtensionImageUploadException()
+        {
+        }
+
+        /// <inheritdoc/>
+        public InvalidExtensionImageUploadException(string message) : base(message)
+        {
+        }
+
+        /// <inheritdoc/>
+        public InvalidExtensionImageUploadException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

backend/src/Designer/Exceptions/AppDevelopment/InvalidLayoutSetIdException.cs

@@ -3,7 +3,7 @@
 namespace Altinn.Studio.Designer.Exceptions.AppDevelopment
 {
     /// <summary>
-    /// Indicates that an error occurred during C# code generation.
+    /// Indicates that a layout set id is invalid
     /// </summary>
     [Serializable]
     public class InvalidLayoutSetIdException : Exception

backend/src/Designer/Filters/AppDevelopment/AppDevelopmentErrorCodes.cs

@@ -5,6 +5,8 @@ public class AppDevelopmentErrorCodes
         public const string NonUniqueLayoutSetIdError = "AD_01";
         public const string NonUniqueTaskForLayoutSetError = "AD_02";
         public const string EmptyLayoutSetIdError = "AD_03";
+        public const string ConflictingFileNameError = "AD_04";
+        public const string UploadedImageNotValid = nameof(UploadedImageNotValid);
     }
 }
 

backend/src/Designer/Filters/AppDevelopment/AppDevelopmentExceptionFilterAttribute.cs

@@ -29,6 +29,14 @@ public override void OnException(ExceptionContext context)
             {
                 context.Result = new ObjectResult(ProblemDetailsUtils.GenerateProblemDetails(context.Exception, AppDevelopmentErrorCodes.EmptyLayoutSetIdError, HttpStatusCode.BadRequest)) { StatusCode = (int)HttpStatusCode.BadRequest };
             }
+            if (context.Exception is ConflictingFileNameException)
+            {
+                context.Result = new ObjectResult(ProblemDetailsUtils.GenerateProblemDetails(context.Exception, AppDevelopmentErrorCodes.ConflictingFileNameError, HttpStatusCode.BadRequest)) { StatusCode = (int)HttpStatusCode.BadRequest };
+            }
+            if (context.Exception is InvalidExtensionImageUploadException)
+            {
+                context.Result = new ObjectResult(ProblemDetailsUtils.GenerateProblemDetails(context.Exception, AppDevelopmentErrorCodes.UploadedImageNotValid, HttpStatusCode.BadRequest)) { StatusCode = (int)HttpStatusCode.BadRequest };
+            }
         }
     }
 }

backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs

@@ -207,6 +207,22 @@ public override async Task<string> SaveXsd(string xsd, string fileName)
             return filePath;
         }
 
+        /// <summary>
+        /// Saves the image to the disk.
+        /// </summary>
+        /// <param name="image">Stream representing the image to be saved.</param>
+        /// <param name="imageFileName">The file name of the image to be saved.</param>
+        /// <returns>A string containing the relative path to the file saved.</returns>
+        public async Task<string> SaveImageAsMemoryStream(MemoryStream image, string imageFileName)
+        {
+            string filePath = Path.Combine(ImagesFolderName, imageFileName);
+            image.Position = 0;
+            await WriteStreamByRelativePathAsync(filePath, image, true);
+            image.Position = 0;
+
+            return filePath;
+        }
+
         /// <summary>
         /// Gets the folder where the data models are stored.
         /// </summary>
@@ -804,19 +820,71 @@ public Stream GetProcessDefinitionFile()
             return OpenStreamByRelativePath(ProcessDefinitionFilePath);
         }
 
+        /// <summary>
+        /// Checks if image already exists in wwwroot
+        /// </summary>
+        /// <param name="imageFilePath">The file path of the image from wwwroot</param>
+        /// <returns>A boolean indication if image exists</returns>
+        public bool DoesImageExist(string imageFilePath)
+        {
+            return FileExistsByRelativePath(GetPathToImage(imageFilePath));
+        }
+
         /// <summary>
         /// Gets specified image from App/wwwroot folder of local repo
         /// </summary>
         /// <param name="imageFilePath">The file path of the image</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The image as stream</returns>
-        public Stream GetImage(string imageFilePath, CancellationToken cancellationToken = default)
+        public Stream GetImageAsStreamByFilePath(string imageFilePath, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
             string imagePath = GetPathToImage(imageFilePath);
             return OpenStreamByRelativePath(imagePath);
         }
 
+        /// <summary>
+        /// Delete specified image from App/wwwroot folder of local repo
+        /// </summary>
+        /// <param name="imageFilePath">The file path of the image</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+        /// <returns>The image as stream</returns>
+        public Task DeleteImageByImageFilePath(string imageFilePath, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            string imagePath = GetPathToImage(imageFilePath);
+            DeleteFileByRelativePath(imagePath);
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Gets all image filePathNames from App/wwwroot folder of local repo
+        /// </summary>
+        /// <returns>Array of file paths to all images in App/wwwroot</returns>
+        public List<string> GetAllImageFileNames()
+        {
+            List<string> allFilePaths = new List<string>();
+            if (!DirectoryExistsByRelativePath(ImagesFolderName))
+            {
+                return allFilePaths;
+            }
+
+            // Make sure to sync this list of fileExtensions in frontend if changed until the below issue is done:
+            // ISSUE: https://github.com/Altinn/altinn-studio/issues/13649
+            string[] allowedExtensions =
+            {
+                ".png", ".jpg", ".jpeg", ".svg", ".gif",
+                ".bmp", ".webp", ".tiff", ".ico", ".heif", ".heic"
+            };
+
+            IEnumerable<string> files = GetFilesByRelativeDirectory(ImagesFolderName, "*.*", true)
+                .Where(file => allowedExtensions.Contains(Path.GetExtension(file).ToLower())).Select(file => Path.GetRelativePath(GetAbsoluteFileOrDirectoryPathSanitized(ImagesFolderName), file));
+
+            allFilePaths.AddRange(files);
+
+            return allFilePaths;
+        }
+
         /// <summary>
         /// Gets the relative path to a json schema model.
         /// </summary>
@@ -827,11 +895,6 @@ private string GetPathToModelJsonSchema(string modelName)
             return Path.Combine(ModelFolderPath, $"{modelName}.schema.json");
         }
 
-        private string GetPathToModelMetadata(string modelName)
-        {
-            return Path.Combine(ModelFolderPath, $"{modelName}.metadata.json");
-        }
-
         private static string GetPathToTexts()
         {
             return Path.Combine(ConfigFolderPath, LanguageResourceFolderName);

backend/src/Designer/Infrastructure/GitRepository/GitRepository.cs

@@ -69,12 +69,18 @@ public IEnumerable<string> FindFiles(string[] searchPatterns, bool recursive = t
         /// </summary>
         /// <param name="relativeDirectory">Relative path to a directory within the repository.</param>
         /// <param name="patternMatch">An optional pattern that the retrieved files must match</param>
-        protected string[] GetFilesByRelativeDirectory(string relativeDirectory, string patternMatch = null)
+        /// <param name="searchInSubdirectories">An optional parameter to also get files in sub directories</param>
+        protected string[] GetFilesByRelativeDirectory(string relativeDirectory, string patternMatch = null, bool searchInSubdirectories = false)
         {
             string absoluteDirectory = GetAbsoluteFileOrDirectoryPathSanitized(relativeDirectory);
 
             Guard.AssertFilePathWithinParentDirectory(RepositoryDirectory, absoluteDirectory);
-            return patternMatch != null ? Directory.GetFiles(absoluteDirectory, patternMatch) : Directory.GetFiles(absoluteDirectory);
+
+            SearchOption searchOption = searchInSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+
+            string searchPatternMatch = patternMatch ?? "*.*";
+
+            return Directory.GetFiles(absoluteDirectory, searchPatternMatch, searchOption);
         }
 
         /// <summary>