try another way to implement the data stucture

UserService.DatabaseLayer/Repositories/UsersRepository.cs

@@ -4,65 +4,99 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
-using DataModels;
 using LinqToDB;
 using LinqToDB.Data;
+using UserService.DatabaseLayer.DataModels;
+using UserService.Infrastructure.DataModels;
 
 namespace UserService.DatabaseLayer.Repositories
 {
-    public class UsersRepository : IUsersRepository
+    public class UsersRepository : BaseRepository, IUsersRepository
     {
-        public UsersRepository()
-        {
-            DataConnection.DefaultSettings = new MySettings();
-
-        }
-
         /// <inheritdoc />
-        public async Task<IReadOnlyList<User>> GetAllAsync(Expression<Func<User, bool>>? predicate = null,
+        public async Task<IReadOnlyList<User>> GetAllAsync(Expression<Func<NodeModel, bool>>? predicate = null,
             CancellationToken token = default)
         {
-            await using var db = new UserServiceDB();
-            return await db.Users.LoadWith(x=> x.Member).LoadWith(x=> x.Member.Node).WhereOrDefault(predicate).ToListAsync(token: token).ConfigureAwait(false);
+            await using var db = new UserService2DB();
+            var users = await db.NodeModels
+                .LoadWith(x=> x.Parent)
+                .Where(x => x.Discriminator == nameof(User))
+                .WhereOrDefault(predicate)
+                .Select(x => new User
+                {
+                    Id = x.Id,
+                    CommonName = x.CommonName,
+                    Description = x.Description,
+                    FirstName = x.FirstName,
+                    LastName = x.LastName,
+                    IsActive = x.IsActive,
+                    EMail = x.EMail, 
+                    ParentId = x.ParentId,
+                })
+                .ToListAsync(token).ConfigureAwait(false);
+            return users;
         }
 
         /// <inheritdoc />
-        public async Task<User?> GetAsync(Expression<Func<User, bool>> predicate, CancellationToken token = default)
+        public async Task<User?> GetAsync(Expression<Func<NodeModel, bool>> predicate, CancellationToken token = default)
         {
-            await using var db = new UserServiceDB();
-            var result = await db.Users.FirstOrDefaultAsync(predicate, token: token).ConfigureAwait(false);
+            await using var db = new UserService2DB();
+            var result = await db.NodeModels
+                .Where(predicate)
+                .Select(x => new User
+                {
+                    Id = x.Id,
+                    CommonName = x.CommonName,
+                    Description = x.Description,
+                    FirstName = x.FirstName,
+                    LastName = x.LastName,
+                    IsActive = x.IsActive,
+                    EMail = x.EMail
+                }).FirstOrDefaultAsync(token).ConfigureAwait(false);
             return result;
         }
 
         /// <inheritdoc />
         public async Task AddAsync(User entity, CancellationToken token = default)
         {
-            await using var db = new UserServiceDB();
-            var nodeId =
-                await db.Nodes.InsertWithInt32IdentityAsync(() => new Node {CommonName = "holger"}, token: token);
-            await db.Members.InsertAsync(() => new Member {Id = nodeId}, token: token);
+            await using var db = new UserService2DB();
 
-            await db.Users.InsertAsync(() => new User
+            await db.NodeModels.InsertAsync(() => new NodeModel
             {
-                Id = nodeId,
+                CommonName = entity.CommonName,
                 FirstName = entity.FirstName,
                 LastName = entity.LastName,
-                IsActive = entity.IsActive
-
-            }, token: token).ConfigureAwait(false);
+                Description = entity.Description,
+                EMail = entity.EMail,
+                IsActive = entity.IsActive,
+                Discriminator = nameof(User),
+            }, token).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<bool> UpdateAsync(User entity, CancellationToken token = default)
         {
-            throw new NotImplementedException();
+            await using var db = new UserService2DB();
+
+            var changedRows = await db.NodeModels.UpdateAsync(x => new NodeModel
+            {
+                Id = entity.Id,
+                CommonName = entity.CommonName,
+                FirstName = entity.FirstName,
+                LastName = entity.LastName,
+                Description = entity.Description,
+                EMail = entity.EMail,
+                IsActive = entity.IsActive,
+                Discriminator = nameof(User),
+            }, token).ConfigureAwait(false);
+            return changedRows > 0;
         }
 
         /// <inheritdoc />
         public async Task DeleteAsync(User entity, CancellationToken token = default)
         {
-            await using var db = new UserServiceDB();
-            await db.Users.DeleteAsync(x => x.Id == entity.Id, token: token);
+            await using var db = new UserService2DB();
+            await db.NodeModels.DeleteAsync(x => x.Id == entity.Id, token).ConfigureAwait(false);
         }
     }
 }