refactor: Make mapper a service. Fix #202.

3 files changed, 76 insertions, 23 deletions

diff --git a/BackEnd/Timeline/Models/Mapper/MapperServiceCollectionExtensions.cs b/BackEnd/Timeline/Models/Mapper/MapperServiceCollectionExtensions.cs
new file mode 100644
index 00000000..c87586d2
--- /dev/null
+++ b/BackEnd/Timeline/Models/Mapper/MapperServiceCollectionExtensions.cs
@@ -0,0 +1,13 @@
+using Microsoft.Extensions.DependencyInjection;

+

+namespace Timeline.Models.Mapper

+{

+    public static class MapperServiceCollectionExtensions

+    {

+        public static void AddMappers(this IServiceCollection services)

+        {

+            services.AddScoped<UserMapper, UserMapper>();

+            services.AddScoped<TimelineMapper, TimelineMapper>();

+        }

+    }

+}

diff --git a/BackEnd/Timeline/Models/Mapper/TimelineMapper.cs b/BackEnd/Timeline/Models/Mapper/TimelineMapper.cs
index 89a5c0c8..14ca8fe9 100644
--- a/BackEnd/Timeline/Models/Mapper/TimelineMapper.cs
+++ b/BackEnd/Timeline/Models/Mapper/TimelineMapper.cs
@@ -1,5 +1,5 @@
-using AutoMapper;

-using Microsoft.AspNetCore.Mvc;

+using Microsoft.AspNetCore.Mvc;

+using Microsoft.EntityFrameworkCore;

 using System.Collections.Generic;

 using System.Globalization;

 using System.Linq;

@@ -11,10 +11,22 @@ using Timeline.Services;
 

 namespace Timeline.Models.Mapper

 {

-    public static class TimelineMapper

+    public class TimelineMapper

     {

-        public static HttpTimeline MapToHttp(this TimelineEntity entity, IUrlHelper urlHelper)

+        private readonly DatabaseContext _database;

+        private readonly UserMapper _userMapper;

+

+        public TimelineMapper(DatabaseContext database, UserMapper userMapper)

+        {

+            _database = database;

+            _userMapper = userMapper;

+        }

+

+        public async Task<HttpTimeline> MapToHttp(TimelineEntity entity, IUrlHelper urlHelper)

         {

+            await _database.Entry(entity).Reference(e => e.Owner).LoadAsync();

+            await _database.Entry(entity).Collection(e => e.Members).Query().Include(m => m.User).LoadAsync();

+

             var timelineName = entity.Name is null ? "@" + entity.Owner.Username : entity.Name;

 

             return new HttpTimeline(

@@ -23,9 +35,9 @@ namespace Timeline.Models.Mapper
                 name: timelineName,

                 nameLastModifed: entity.NameLastModified,

                 description: entity.Description ?? "",

-                owner: entity.Owner.MapToHttp(urlHelper),

+                owner: await _userMapper.MapToHttp(entity.Owner, urlHelper),

                 visibility: entity.Visibility,

-                members: entity.Members.Select(m => m.User.MapToHttp(urlHelper)).ToList(),

+                members: await _userMapper.MapToHttp(entity.Members.Select(m => m.User).ToList(), urlHelper),

                 createTime: entity.CreateTime,

                 lastModified: entity.LastModified,

                 links: new HttpTimelineLinks(

@@ -35,13 +47,18 @@ namespace Timeline.Models.Mapper
             );

         }

 

-        public static List<HttpTimeline> MapToHttp(this List<TimelineEntity> entites, IUrlHelper urlHelper)

+        public async Task<List<HttpTimeline>> MapToHttp(List<TimelineEntity> entities, IUrlHelper urlHelper)

         {

-            return entites.Select(e => e.MapToHttp(urlHelper)).ToList();

+            var result = new List<HttpTimeline>();

+            foreach (var entity in entities)

+            {

+                result.Add(await MapToHttp(entity, urlHelper));

+            }

+            return result;

         }

 

 

-        public static HttpTimelinePost MapToHttp(this TimelinePostEntity entity, string timelineName, IUrlHelper urlHelper)

+        public async Task<HttpTimelinePost> MapToHttp(TimelinePostEntity entity, string timelineName, IUrlHelper urlHelper)

         {

             HttpTimelinePostContent? content = null;

 

@@ -67,19 +84,33 @@ namespace Timeline.Models.Mapper
                 };

             }

 

+            await _database.Entry(entity).Reference(e => e.Author).LoadAsync();

+

+            HttpUser? author = null;

+

+            if (entity.Author is not null)

+            {

+                author = await _userMapper.MapToHttp(entity.Author, urlHelper);

+            }

+

             return new HttpTimelinePost(

                     id: entity.LocalId,

                     content: content,

                     deleted: content is null,

                     time: entity.Time,

-                    author: entity.Author?.MapToHttp(urlHelper),

+                    author: author,

                     lastUpdated: entity.LastUpdated

                 );

         }

 

-        public static List<HttpTimelinePost> MapToHttp(this List<TimelinePostEntity> entities, string timelineName, IUrlHelper urlHelper)

+        public async Task<List<HttpTimelinePost>> MapToHttp(List<TimelinePostEntity> entities, string timelineName, IUrlHelper urlHelper)

         {

-            return entities.Select(e => e.MapToHttp(timelineName, urlHelper)).ToList();

+            var result = new List<HttpTimelinePost>();

+            foreach (var entity in entities)

+            {

+                result.Add(await MapToHttp(entity, timelineName, urlHelper));

+            }

+            return result;

         }

     }

 }

diff --git a/BackEnd/Timeline/Models/Mapper/UserMapper.cs b/BackEnd/Timeline/Models/Mapper/UserMapper.cs
index 3255dca9..e6db4225 100644
--- a/BackEnd/Timeline/Models/Mapper/UserMapper.cs
+++ b/BackEnd/Timeline/Models/Mapper/UserMapper.cs
@@ -1,6 +1,6 @@
 using Microsoft.AspNetCore.Mvc;

 using System.Collections.Generic;

-using System.Linq;

+using System.Threading.Tasks;

 using Timeline.Controllers;

 using Timeline.Entities;

 using Timeline.Models.Http;

@@ -8,15 +8,24 @@ using Timeline.Services;
 

 namespace Timeline.Models.Mapper

 {

-    public static class UserMapper

+    public class UserMapper

     {

-        public static HttpUser MapToHttp(this UserEntity entity, IUrlHelper urlHelper)

+        private readonly DatabaseContext _database;

+        private readonly IUserPermissionService _userPermissionService;

+

+        public UserMapper(DatabaseContext database, IUserPermissionService userPermissionService)

+        {

+            _database = database;

+            _userPermissionService = userPermissionService;

+        }

+

+        public async Task<HttpUser> MapToHttp(UserEntity entity, IUrlHelper urlHelper)

         {

             return new HttpUser(

                 uniqueId: entity.UniqueId,

                 username: entity.Username,

                 nickname: string.IsNullOrEmpty(entity.Nickname) ? entity.Username : entity.Nickname,

-                permissions: MapPermission(entity),

+                permissions: (await _userPermissionService.GetPermissionsOfUserAsync(entity.Id, false)).ToStringList(),

                 links: new HttpUserLinks(

                     self: urlHelper.ActionLink(nameof(UserController.Get), nameof(UserController)[0..^nameof(Controller).Length], new { entity.Username }),

                     avatar: urlHelper.ActionLink(nameof(UserAvatarController.Get), nameof(UserAvatarController)[0..^nameof(Controller).Length], new { entity.Username }),

@@ -25,14 +34,14 @@ namespace Timeline.Models.Mapper
             );

         }

 

-        public static List<HttpUser> MapToHttp(this List<UserEntity> entities, IUrlHelper urlHelper)

-        {

-            return entities.Select(e => e.MapToHttp(urlHelper)).ToList();

-        }

-

-        private static List<string> MapPermission(UserEntity entity)

+        public async Task<List<HttpUser>> MapToHttp(List<UserEntity> entities, IUrlHelper urlHelper)

         {

-            return entity.Permissions.Select(p => p.Permission).ToList();

+            var result = new List<HttpUser>();

+            foreach (var entity in entities)

+            {

+                result.Add(await MapToHttp(entity, urlHelper));

+            }

+            return result;

         }

     }

 }