...

3 files changed, 101 insertions, 27 deletions

diff --git a/BackEnd/Timeline.Tests/ServiceTests/User/RegisterCode/RegisterCodeServiceTest.cs b/BackEnd/Timeline.Tests/ServiceTests/User/RegisterCode/RegisterCodeServiceTest.cs
index 6542696f..a0e3d20e 100644
--- a/BackEnd/Timeline.Tests/ServiceTests/User/RegisterCode/RegisterCodeServiceTest.cs
+++ b/BackEnd/Timeline.Tests/ServiceTests/User/RegisterCode/RegisterCodeServiceTest.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;

+using System.Threading.Tasks;
 using FluentAssertions;
 using Timeline.Services.User.RegisterCode;
 using Xunit;
@@ -11,7 +12,7 @@ namespace Timeline.Tests.ServiceTests.User.RegisterCode
 
         protected override void OnInitialize()
         {
-            _registerCodeService = new RegisterCodeService(Database);
+            _registerCodeService = new RegisterCodeService(Database, UserService);
         }
 
         protected override void OnDispose()
@@ -20,23 +21,73 @@ namespace Timeline.Tests.ServiceTests.User.RegisterCode
         }
 
         [Fact]
-        public async Task Test()
+        public async Task RegisterCodeTest()
         {
-            var a = await _registerCodeService.GetCurrentCode(AdminId);
+            var a = await _registerCodeService.GetCurrentCodeAsync(AdminId);
             a.Should().BeNull();
-            var b = await _registerCodeService.CreateNewCode(AdminId);
+            var b = await _registerCodeService.CreateNewCodeAsync(AdminId);
             b.Should().NotBeNullOrEmpty();
-            var c = await _registerCodeService.GetCurrentCode(AdminId);
+            var c = await _registerCodeService.GetCurrentCodeAsync(AdminId);
             c.Should().Be(b);
-            var d = await _registerCodeService.CreateNewCode(AdminId);
+            var d = await _registerCodeService.CreateNewCodeAsync(AdminId);
             d.Should().NotBe(b);
-            var e = await _registerCodeService.GetCodeOwner(d);
+            var e = await _registerCodeService.GetCodeOwnerAsync(d);
             e.Should().Be(AdminId);
-            var f = await _registerCodeService.GetCodeOwner(b);
+            var f = await _registerCodeService.GetCodeOwnerAsync(b);
             f.Should().BeNull();
-            var g = await _registerCodeService.GetCodeOwner(b, false);
+            var g = await _registerCodeService.GetCodeOwnerAsync(b, false);
             g.Should().Be(AdminId);
         }
+
+        [Fact]
+        public async Task RegisterInfoTest()
+        {
+            var registerCode = await _registerCodeService.CreateNewCodeAsync(AdminId);
+
+            var a = await _registerCodeService.GetUserRegisterInfoAsync(UserId);
+            a.Should().BeNull();
+
+            var dateTime = DateTime.UtcNow;
+
+            var b = await _registerCodeService.CreateRegisterInfoAsync(UserId, registerCode, dateTime);
+            b.UserId.Should().Be(UserId);
+            b.RegisterCode.Should().Be(registerCode);
+            b.IntroducerId.Should().Be(AdminId);
+            b.RegisterTime.Should().Be(dateTime);
+
+            var c = await _registerCodeService.GetUserRegisterInfoAsync(UserId);
+            c.Should().NotBeNull();
+            c!.UserId.Should().Be(UserId);
+            c.RegisterCode.Should().Be(registerCode);
+            c.IntroducerId.Should().Be(AdminId);
+            c.RegisterTime.Should().Be(dateTime);
+        }
+
+        [Fact]
+        public async Task RegisterInfoTestWithOldCode()
+        {
+            await _registerCodeService.CreateNewCodeAsync(AdminId);
+
+            // Make the old code disabled.
+            var registerCode = await _registerCodeService.CreateNewCodeAsync(AdminId);
+
+            var a = await _registerCodeService.GetUserRegisterInfoAsync(UserId);
+            a.Should().BeNull();
+
+            var dateTime = DateTime.UtcNow;
+
+            var b = await _registerCodeService.CreateRegisterInfoAsync(UserId, registerCode, dateTime);
+            b.UserId.Should().Be(UserId);
+            b.RegisterCode.Should().Be(registerCode);
+            b.IntroducerId.Should().Be(AdminId);
+            b.RegisterTime.Should().Be(dateTime);
+
+            var c = await _registerCodeService.GetUserRegisterInfoAsync(UserId);
+            c.Should().NotBeNull();
+            c!.UserId.Should().Be(UserId);
+            c.RegisterCode.Should().Be(registerCode);
+            c.IntroducerId.Should().Be(AdminId);
+            c.RegisterTime.Should().Be(dateTime);
+        }
     }
 }
-
diff --git a/BackEnd/Timeline/Services/User/RegisterCode/IRegisterCodeService.cs b/BackEnd/Timeline/Services/User/RegisterCode/IRegisterCodeService.cs
index 65decefc..e0031a38 100644
--- a/BackEnd/Timeline/Services/User/RegisterCode/IRegisterCodeService.cs
+++ b/BackEnd/Timeline/Services/User/RegisterCode/IRegisterCodeService.cs
@@ -13,44 +13,43 @@ namespace Timeline.Services.User.RegisterCode
         /// <param name="code">The register code.</param>
         /// <param name="onlyEnabled">If true, only when code is enabled the owner id is returned.</param>
         /// <returns>A task contains the owner of the register code. Null of the code does not exist or is not enabled.</returns>
-        Task<long?> GetCodeOwner(string code, bool onlyEnabled = true);
+        Task<long?> GetCodeOwnerAsync(string code, bool onlyEnabled = true);
 
         /// <summary>
         /// Get the current enabled register code of the user or null if there is none.
         /// </summary>
         /// <param name="userId">The user id.</param>
         /// <returns>A task contains current enabled register code or null if there is none.</returns>
-        Task<string?> GetCurrentCode(long userId);
+        Task<string?> GetCurrentCodeAsync(long userId);
 
         /// <summary>
         /// Create a new register code for a user, enable it and disable the previous one if there is a previous one.
         /// </summary>
         /// <param name="userId">The user id.</param>
         /// <returns>A task contains the new register code.</returns>
-        Task<string> CreateNewCode(long userId);
+        Task<string> CreateNewCodeAsync(long userId);
 
         /// <summary>
         /// Record a register info for a user.
         /// </summary>
         /// <param name="userId">The newly-registered user.</param>
-        /// <param name="introducerId">The introducer user id.</param>
         /// <param name="registerCode">The register code.</param>
         /// <param name="registerTime">The register time.</param>
         /// <returns>The created register info.</returns>
-        Task<UserRegisterInfo> CreateRegisterInfo(long userId, long introducerId, string registerCode, DateTime registerTime);
+        Task<UserRegisterInfo> CreateRegisterInfoAsync(long userId, string registerCode, DateTime registerTime);
 
         /// <summary>
         /// Get register info of a user if there is one.
         /// </summary>
         /// <param name="userId">The user id.</param>
         /// <returns>The user register info if there is one. Or null if there is not.</returns>
-        Task<UserRegisterInfo?> GetUserRegisterInfo(long userId);
+        Task<UserRegisterInfo?> GetUserRegisterInfoAsync(long userId);
 
         /// <summary>
         /// Get the list of user register info of the specified introducer.
         /// </summary>
         /// <param name="introducerId"></param>
         /// <returns>The list of user register info.</returns>
-        Task<List<UserRegisterInfo>> GetUserRegisterInfoOfIntroducer(long introducerId);
+        Task<List<UserRegisterInfo>> GetUserRegisterInfoOfIntroducerAsync(long introducerId);
     }
 }
diff --git a/BackEnd/Timeline/Services/User/RegisterCode/RegisterCodeService.cs b/BackEnd/Timeline/Services/User/RegisterCode/RegisterCodeService.cs
index eb8bc37a..97a685d6 100644
--- a/BackEnd/Timeline/Services/User/RegisterCode/RegisterCodeService.cs
+++ b/BackEnd/Timeline/Services/User/RegisterCode/RegisterCodeService.cs
@@ -12,16 +12,22 @@ namespace Timeline.Services.User.RegisterCode
     public class RegisterCodeService : IRegisterCodeService, IDisposable
     {
         private readonly DatabaseContext _databaseContext;
+        private readonly IUserService _userService;
+
         private readonly RandomNumberGenerator _randomNumberGenerator;
 
-        public RegisterCodeService(DatabaseContext databaseContext)
+        public RegisterCodeService(DatabaseContext databaseContext, IUserService userService)
         {
             _databaseContext = databaseContext;
+            _userService = userService;
+
             _randomNumberGenerator = RandomNumberGenerator.Create();
         }
 
-        public async Task<string> CreateNewCode(long userId)
+        public async Task<string> CreateNewCodeAsync(long userId)
         {
+            await _userService.CheckUserExistenceAsync(userId);
+
             var oldEntity = await _databaseContext.RegisterCodes.Where(r => r.OwnerId == userId && r.Enabled).SingleOrDefaultAsync();
 
             if (oldEntity is not null)
@@ -42,9 +48,24 @@ namespace Timeline.Services.User.RegisterCode
             return newEntity.Code;
         }
 
-        public Task<UserRegisterInfo> CreateRegisterInfo(long userId, long introducerId, string registerCode, DateTime registerTime)
+        public async Task<UserRegisterInfo> CreateRegisterInfoAsync(long userId, string registerCode, DateTime registerTime)
         {
-            throw new NotImplementedException();
+            await _userService.CheckUserExistenceAsync(userId);
+
+            var introducerId = await GetCodeOwnerAsync(registerCode, false);
+
+            var entity = new UserRegisterInfo()
+            {
+                UserId = userId,
+                IntroducerId = introducerId,
+                RegisterCode = registerCode,
+                RegisterTime = registerTime
+            };
+
+            _databaseContext.UserRegisterInfos.Add(entity);
+            await _databaseContext.SaveChangesAsync();
+
+            return entity;
         }
 
         public void Dispose()
@@ -52,7 +73,7 @@ namespace Timeline.Services.User.RegisterCode
             _randomNumberGenerator.Dispose();
         }
 
-        public async Task<long?> GetCodeOwner(string code, bool onlyEnabled = true)
+        public async Task<long?> GetCodeOwnerAsync(string code, bool onlyEnabled = true)
         {
             var entity = await _databaseContext.RegisterCodes.Where(r => r.Code == code).SingleOrDefaultAsync();
             if (entity is null) return null;
@@ -60,18 +81,21 @@ namespace Timeline.Services.User.RegisterCode
             return entity.OwnerId;
         }
 
-        public async Task<string?> GetCurrentCode(long userId)
+        public async Task<string?> GetCurrentCodeAsync(long userId)
         {
+            await _userService.CheckUserExistenceAsync(userId);
+
             var entity = await _databaseContext.RegisterCodes.Where(r => r.OwnerId == userId && r.Enabled).SingleOrDefaultAsync();
             return entity?.Code;
         }
 
-        public Task<UserRegisterInfo?> GetUserRegisterInfo(long userId)
+        public async Task<UserRegisterInfo?> GetUserRegisterInfoAsync(long userId)
         {
-            throw new NotImplementedException();
+            await _userService.CheckUserExistenceAsync(userId);
+            return await _databaseContext.UserRegisterInfos.Where(i => i.UserId == userId).SingleOrDefaultAsync();
         }
 
-        public Task<List<UserRegisterInfo>> GetUserRegisterInfoOfIntroducer(long introducerId)
+        public Task<List<UserRegisterInfo>> GetUserRegisterInfoOfIntroducerAsync(long introducerId)
         {
             throw new NotImplementedException();
         }